LLVM  13.0.0git
SampleProfReader.h
Go to the documentation of this file.
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/StringMap.h"
231 #include "llvm/ADT/StringRef.h"
232 #include "llvm/IR/DiagnosticInfo.h"
233 #include "llvm/IR/Function.h"
234 #include "llvm/IR/LLVMContext.h"
235 #include "llvm/IR/ProfileSummary.h"
236 #include "llvm/ProfileData/GCOV.h"
238 #include "llvm/Support/Debug.h"
240 #include "llvm/Support/ErrorOr.h"
243 #include <algorithm>
244 #include <cstdint>
245 #include <memory>
246 #include <string>
247 #include <system_error>
248 #include <vector>
249 
250 namespace llvm {
251 
252 class raw_ostream;
253 class Twine;
254 
255 namespace sampleprof {
256 
257 class SampleProfileReader;
258 
259 /// SampleProfileReaderItaniumRemapper remaps the profile data from a
260 /// sample profile data reader, by applying a provided set of equivalences
261 /// between components of the symbol names in the profile.
263 public:
264  SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B,
265  std::unique_ptr<SymbolRemappingReader> SRR,
267  : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
268  assert(Remappings && "Remappings cannot be nullptr");
269  }
270 
271  /// Create a remapper from the given remapping file. The remapper will
272  /// be used for profile read in by Reader.
274  create(const std::string Filename, SampleProfileReader &Reader,
275  LLVMContext &C);
276 
277  /// Create a remapper from the given Buffer. The remapper will
278  /// be used for profile read in by Reader.
280  create(std::unique_ptr<MemoryBuffer> &B, SampleProfileReader &Reader,
281  LLVMContext &C);
282 
283  /// Apply remappings to the profile read by Reader.
284  void applyRemapping(LLVMContext &Ctx);
285 
286  bool hasApplied() { return RemappingApplied; }
287 
288  /// Insert function name into remapper.
289  void insert(StringRef FunctionName) { Remappings->insert(FunctionName); }
290 
291  /// Query whether there is equivalent in the remapper which has been
292  /// inserted.
293  bool exist(StringRef FunctionName) {
294  return Remappings->lookup(FunctionName);
295  }
296 
297  /// Return the equivalent name in the profile for \p FunctionName if
298  /// it exists.
300 
301 private:
302  // The buffer holding the content read from remapping file.
303  std::unique_ptr<MemoryBuffer> Buffer;
304  std::unique_ptr<SymbolRemappingReader> Remappings;
305  // Map remapping key to the name in the profile. By looking up the
306  // key in the remapper, a given new name can be mapped to the
307  // cannonical name using the NameMap.
309  // The Reader the remapper is servicing.
310  SampleProfileReader &Reader;
311  // Indicate whether remapping has been applied to the profile read
312  // by Reader -- by calling applyRemapping.
313  bool RemappingApplied = false;
314 };
315 
316 /// Sample-based profile reader.
317 ///
318 /// Each profile contains sample counts for all the functions
319 /// executed. Inside each function, statements are annotated with the
320 /// collected samples on all the instructions associated with that
321 /// statement.
322 ///
323 /// For this to produce meaningful data, the program needs to be
324 /// compiled with some debug information (at minimum, line numbers:
325 /// -gline-tables-only). Otherwise, it will be impossible to match IR
326 /// instructions to the line numbers collected by the profiler.
327 ///
328 /// From the profile file, we are interested in collecting the
329 /// following information:
330 ///
331 /// * A list of functions included in the profile (mangled names).
332 ///
333 /// * For each function F:
334 /// 1. The total number of samples collected in F.
335 ///
336 /// 2. The samples collected at each line in F. To provide some
337 /// protection against source code shuffling, line numbers should
338 /// be relative to the start of the function.
339 ///
340 /// The reader supports two file formats: text and binary. The text format
341 /// is useful for debugging and testing, while the binary format is more
342 /// compact and I/O efficient. They can both be used interchangeably.
344 public:
345  SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
347  : Profiles(0), Ctx(C), Buffer(std::move(B)), Format(Format) {}
348 
349  virtual ~SampleProfileReader() = default;
350 
351  /// Read and validate the file header.
352  virtual std::error_code readHeader() = 0;
353 
354  /// Set the bits for FS discriminators. Parameter Pass specify the sequence
355  /// number, Pass == i is for the i-th round of adding FS discriminators.
356  /// Pass == 0 is for using base discriminators.
359  }
360 
361  /// Get the bitmask the discriminators: For FS profiles, return the bit
362  /// mask for this pass. For non FS profiles, return (unsigned) -1.
364  if (!ProfileIsFS)
365  return 0xFFFFFFFF;
366  assert((MaskedBitFrom != 0) && "MaskedBitFrom is not set properly");
367  return getN1Bits(MaskedBitFrom);
368  }
369 
370  /// The interface to read sample profiles from the associated file.
371  std::error_code read() {
372  if (std::error_code EC = readImpl())
373  return EC;
374  if (Remapper)
375  Remapper->applyRemapping(Ctx);
378  }
379 
380  /// The implementaion to read sample profiles from the associated file.
381  virtual std::error_code readImpl() = 0;
382 
383  /// Print the profile for \p FName on stream \p OS.
384  void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs());
385 
386  /// Collect functions with definitions in Module M. For reader which
387  /// support loading function profiles on demand, return true when the
388  /// reader has been given a module. Always return false for reader
389  /// which doesn't support loading function profiles on demand.
390  virtual bool collectFuncsFromModule() { return false; }
391 
392  /// Print all the profiles on stream \p OS.
393  void dump(raw_ostream &OS = dbgs());
394 
395  /// Return the samples collected for function \p F.
397  // The function name may have been updated by adding suffix. Call
398  // a helper to (optionally) strip off suffixes so that we can
399  // match against the original function name in the profile.
401  return getSamplesFor(CanonName);
402  }
403 
404  /// Return the samples collected for function \p F, create empty
405  /// FunctionSamples if it doesn't exist.
407  std::string FGUID;
409  CanonName = getRepInFormat(CanonName, useMD5(), FGUID);
410  return &Profiles[CanonName];
411  }
412 
413  /// Return the samples collected for function \p F.
415  std::string FGUID;
416  Fname = getRepInFormat(Fname, useMD5(), FGUID);
417  auto It = Profiles.find(Fname);
418  if (It != Profiles.end())
419  return &It->second;
420 
421  if (Remapper) {
422  if (auto NameInProfile = Remapper->lookUpNameInProfile(Fname)) {
423  auto It = Profiles.find(*NameInProfile);
424  if (It != Profiles.end())
425  return &It->second;
426  }
427  }
428  return nullptr;
429  }
430 
431  /// Return all the profiles.
433 
434  /// Report a parse error message.
435  void reportError(int64_t LineNumber, const Twine &Msg) const {
436  Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
437  LineNumber, Msg));
438  }
439 
440  /// Create a sample profile reader appropriate to the file format.
441  /// Create a remapper underlying if RemapFilename is not empty.
442  /// Parameter P specifies the FSDiscriminatorPass.
444  create(const std::string Filename, LLVMContext &C,
446  const std::string RemapFilename = "");
447 
448  /// Create a sample profile reader from the supplied memory buffer.
449  /// Create a remapper underlying if RemapFilename is not empty.
450  /// Parameter P specifies the FSDiscriminatorPass.
452  create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
454  const std::string RemapFilename = "");
455 
456  /// Return the profile summary.
457  ProfileSummary &getSummary() const { return *(Summary.get()); }
458 
459  MemoryBuffer *getBuffer() const { return Buffer.get(); }
460 
461  /// \brief Return the profile format.
463 
464  /// Whether input profile is based on pseudo probes.
465  bool profileIsProbeBased() const { return ProfileIsProbeBased; }
466 
467  /// Whether input profile is fully context-sensitive
468  bool profileIsCS() const { return ProfileIsCS; }
469 
470  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
471  return nullptr;
472  };
473 
474  /// It includes all the names that have samples either in outline instance
475  /// or inline instance.
476  virtual std::vector<StringRef> *getNameTable() { return nullptr; }
477  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
478 
479  /// Return whether names in the profile are all MD5 numbers.
480  virtual bool useMD5() { return false; }
481 
482  /// Don't read profile without context if the flag is set. This is only meaningful
483  /// for ExtBinary format.
484  virtual void setSkipFlatProf(bool Skip) {}
485  /// Return whether any name in the profile contains ".__uniq." suffix.
486  virtual bool hasUniqSuffix() { return false; }
487 
489 
490  void setModule(const Module *Mod) { M = Mod; }
491 
492 protected:
493  /// Map every function to its associated profile.
494  ///
495  /// The profile of every function executed at runtime is collected
496  /// in the structure FunctionSamples. This maps function objects
497  /// to their corresponding profiles.
499 
500  /// LLVM context used to emit diagnostics.
502 
503  /// Memory buffer holding the profile file.
504  std::unique_ptr<MemoryBuffer> Buffer;
505 
506  /// Profile summary information.
507  std::unique_ptr<ProfileSummary> Summary;
508 
509  /// Take ownership of the summary of this reader.
510  static std::unique_ptr<ProfileSummary>
512  return std::move(Reader.Summary);
513  }
514 
515  /// Compute summary for this profile.
516  void computeSummary();
517 
518  std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper;
519 
520  /// \brief Whether samples are collected based on pseudo probes.
521  bool ProfileIsProbeBased = false;
522 
523  /// Whether function profiles are context-sensitive.
524  bool ProfileIsCS = false;
525 
526  /// Number of context-sensitive profiles.
528 
529  /// Whether the function profiles use FS discriminators.
530  bool ProfileIsFS = false;
531 
532  /// \brief The format of sample.
534 
535  /// \brief The current module being compiled if SampleProfileReader
536  /// is used by compiler. If SampleProfileReader is used by other
537  /// tools which are not compiler, M is usually nullptr.
538  const Module *M = nullptr;
539 
540  /// Zero out the discriminator bits higher than bit MaskedBitFrom (0 based).
541  /// The default is to keep all the bits.
543 };
544 
546 public:
547  SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
549 
550  /// Read and validate the file header.
551  std::error_code readHeader() override { return sampleprof_error::success; }
552 
553  /// Read sample profiles from the associated file.
554  std::error_code readImpl() override;
555 
556  /// Return true if \p Buffer is in the format supported by this class.
557  static bool hasFormat(const MemoryBuffer &Buffer);
558 };
559 
561 public:
562  SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
565 
566  /// Read and validate the file header.
567  virtual std::error_code readHeader() override;
568 
569  /// Read sample profiles from the associated file.
570  std::error_code readImpl() override;
571 
572  /// It includes all the names that have samples either in outline instance
573  /// or inline instance.
574  virtual std::vector<StringRef> *getNameTable() override { return &NameTable; }
575 
576 protected:
577  /// Read a numeric value of type T from the profile.
578  ///
579  /// If an error occurs during decoding, a diagnostic message is emitted and
580  /// EC is set.
581  ///
582  /// \returns the read value.
583  template <typename T> ErrorOr<T> readNumber();
584 
585  /// Read a numeric value of type T from the profile. The value is saved
586  /// without encoded.
587  template <typename T> ErrorOr<T> readUnencodedNumber();
588 
589  /// Read a string from the profile.
590  ///
591  /// If an error occurs during decoding, a diagnostic message is emitted and
592  /// EC is set.
593  ///
594  /// \returns the read value.
596 
597  /// Read the string index and check whether it overflows the table.
598  template <typename T> inline ErrorOr<uint32_t> readStringIndex(T &Table);
599 
600  /// Return true if we've reached the end of file.
601  bool at_eof() const { return Data >= End; }
602 
603  /// Read the next function profile instance.
604  std::error_code readFuncProfile(const uint8_t *Start);
605 
606  /// Read the contents of the given profile instance.
607  std::error_code readProfile(FunctionSamples &FProfile);
608 
609  /// Read the contents of Magic number and Version number.
610  std::error_code readMagicIdent();
611 
612  /// Read profile summary.
613  std::error_code readSummary();
614 
615  /// Read the whole name table.
616  virtual std::error_code readNameTable();
617 
618  /// Points to the current location in the buffer.
619  const uint8_t *Data = nullptr;
620 
621  /// Points to the end of the buffer.
622  const uint8_t *End = nullptr;
623 
624  /// Function name table.
625  std::vector<StringRef> NameTable;
626 
627  /// Read a string indirectly via the name table.
629 
630 private:
631  std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
632  virtual std::error_code verifySPMagic(uint64_t Magic) = 0;
633 };
634 
636 private:
637  virtual std::error_code verifySPMagic(uint64_t Magic) override;
638 
639 public:
640  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
643 
644  /// \brief Return true if \p Buffer is in the format supported by this class.
645  static bool hasFormat(const MemoryBuffer &Buffer);
646 };
647 
648 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines
649 /// the basic structure of the extensible binary format.
650 /// The format is organized in sections except the magic and version number
651 /// at the beginning. There is a section table before all the sections, and
652 /// each entry in the table describes the entry type, start, size and
653 /// attributes. The format in each section is defined by the section itself.
654 ///
655 /// It is easy to add a new section while maintaining the backward
656 /// compatibility of the profile. Nothing extra needs to be done. If we want
657 /// to extend an existing section, like add cache misses information in
658 /// addition to the sample count in the profile body, we can add a new section
659 /// with the extension and retire the existing section, and we could choose
660 /// to keep the parser of the old section if we want the reader to be able
661 /// to read both new and old format profile.
662 ///
663 /// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the
664 /// commonly used sections of a profile in extensible binary format. It is
665 /// possible to define other types of profile inherited from
666 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase.
668 private:
669  std::error_code decompressSection(const uint8_t *SecStart,
670  const uint64_t SecSize,
671  const uint8_t *&DecompressBuf,
672  uint64_t &DecompressBufSize);
673 
674  BumpPtrAllocator Allocator;
675 
676 protected:
677  std::vector<SecHdrTableEntry> SecHdrTable;
678  std::error_code readSecHdrTableEntry(uint32_t Idx);
679  std::error_code readSecHdrTable();
680 
681  std::error_code readFuncMetadata(bool ProfileHasAttribute);
682  std::error_code readFuncOffsetTable();
683  std::error_code readFuncProfiles();
684  std::error_code readMD5NameTable();
685  std::error_code readNameTableSec(bool IsMD5);
686  std::error_code readProfileSymbolList();
687 
688  virtual std::error_code readHeader() override;
689  virtual std::error_code verifySPMagic(uint64_t Magic) override = 0;
690  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
691  const SecHdrTableEntry &Entry);
692  // placeholder for subclasses to dispatch their own section readers.
693  virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0;
694  virtual ErrorOr<StringRef> readStringFromTable() override;
695 
696  std::unique_ptr<ProfileSymbolList> ProfSymList;
697 
698  /// The table mapping from function name to the offset of its FunctionSample
699  /// towards file start.
701  /// The set containing the functions to use when compiling a module.
703 
704  /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
705  /// need to be read in up front and can be directly accessed using index.
706  bool FixedLengthMD5 = false;
707  /// The starting address of NameTable containing fixed length MD5.
708  const uint8_t *MD5NameMemStart = nullptr;
709 
710  /// If MD5 is used in NameTable section, the section saves uint64_t data.
711  /// The uint64_t data has to be converted to a string and then the string
712  /// will be used to initialize StringRef in NameTable.
713  /// Note NameTable contains StringRef so it needs another buffer to own
714  /// the string data. MD5StringBuf serves as the string buffer that is
715  /// referenced by NameTable (vector of StringRef). We make sure
716  /// the lifetime of MD5StringBuf is not shorter than that of NameTable.
717  std::unique_ptr<std::vector<std::string>> MD5StringBuf;
718 
719  /// If SkipFlatProf is true, skip the sections with
720  /// SecFlagFlat flag.
721  bool SkipFlatProf = false;
722 
723 public:
724  SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B,
727 
728  /// Read sample profiles in extensible format from the associated file.
729  std::error_code readImpl() override;
730 
731  /// Get the total size of all \p Type sections.
732  uint64_t getSectionSize(SecType Type);
733  /// Get the total size of header and all sections.
734  uint64_t getFileSize();
735  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) override;
736 
737  /// Collect functions with definitions in Module M. Return true if
738  /// the reader has been given a module.
739  bool collectFuncsFromModule() override;
740 
741  /// Return whether names in the profile are all MD5 numbers.
742  virtual bool useMD5() override { return MD5StringBuf.get(); }
743 
744  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
745  return std::move(ProfSymList);
746  };
747 
748  virtual void setSkipFlatProf(bool Skip) override { SkipFlatProf = Skip; }
749 };
750 
752 private:
753  virtual std::error_code verifySPMagic(uint64_t Magic) override;
754  virtual std::error_code
755  readCustomSection(const SecHdrTableEntry &Entry) override {
757  };
758 
759 public:
760  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
763 
764  /// \brief Return true if \p Buffer is in the format supported by this class.
765  static bool hasFormat(const MemoryBuffer &Buffer);
766 };
767 
769 private:
770  /// Function name table.
771  std::vector<std::string> NameTable;
772  /// The table mapping from function name to the offset of its FunctionSample
773  /// towards file start.
774  DenseMap<StringRef, uint64_t> FuncOffsetTable;
775  /// The set containing the functions to use when compiling a module.
776  DenseSet<StringRef> FuncsToUse;
777  virtual std::error_code verifySPMagic(uint64_t Magic) override;
778  virtual std::error_code readNameTable() override;
779  /// Read a string indirectly via the name table.
780  virtual ErrorOr<StringRef> readStringFromTable() override;
781  virtual std::error_code readHeader() override;
782  std::error_code readFuncOffsetTable();
783 
784 public:
785  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
786  LLVMContext &C)
788 
789  /// \brief Return true if \p Buffer is in the format supported by this class.
790  static bool hasFormat(const MemoryBuffer &Buffer);
791 
792  /// Read samples only for functions to use.
793  std::error_code readImpl() override;
794 
795  /// Collect functions with definitions in Module M. Return true if
796  /// the reader has been given a module.
797  bool collectFuncsFromModule() override;
798 
799  /// Return whether names in the profile are all MD5 numbers.
800  virtual bool useMD5() override { return true; }
801 };
802 
804 
805 // Supported histogram types in GCC. Currently, we only need support for
806 // call target histograms.
807 enum HistType {
816 };
817 
819 public:
820  SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
822  GcovBuffer(Buffer.get()) {}
823 
824  /// Read and validate the file header.
825  std::error_code readHeader() override;
826 
827  /// Read sample profiles from the associated file.
828  std::error_code readImpl() override;
829 
830  /// Return true if \p Buffer is in the format supported by this class.
831  static bool hasFormat(const MemoryBuffer &Buffer);
832 
833 protected:
834  std::error_code readNameTable();
835  std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack,
836  bool Update, uint32_t Offset);
837  std::error_code readFunctionProfiles();
838  std::error_code skipNextWord();
839  template <typename T> ErrorOr<T> readNumber();
841 
842  /// Read the section tag and check that it's the same as \p Expected.
843  std::error_code readSectionTag(uint32_t Expected);
844 
845  /// GCOV buffer containing the profile.
847 
848  /// Function names in this profile.
849  std::vector<std::string> Names;
850 
851  /// GCOV tags used to separate sections in the profile file.
852  static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
853  static const uint32_t GCOVTagAFDOFunction = 0xac000000;
854 };
855 
856 } // end namespace sampleprof
857 
858 } // end namespace llvm
859 
860 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::sampleprof::SampleProfileReader::ProfileIsFS
bool ProfileIsFS
Whether the function profiles use FS discriminators.
Definition: SampleProfReader.h:530
MemoryBuffer.h
llvm::sampleprof::SampleProfileReader::dump
void dump(raw_ostream &OS=dbgs())
Print all the profiles on stream OS.
Definition: SampleProfReader.cpp:68
llvm::sampleprof::SampleProfileReaderText
Definition: SampleProfReader.h:545
llvm::sampleprof::SampleProfileReaderBinary::readNameTable
virtual std::error_code readNameTable()
Read the whole name table.
Definition: SampleProfReader.cpp:935
llvm::sampleprof::SampleProfileReader::CSProfileCount
uint32_t CSProfileCount
Number of context-sensitive profiles.
Definition: SampleProfReader.h:527
llvm::sampleprof::SampleProfileReaderText::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:240
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FixedLengthMD5
bool FixedLengthMD5
Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't need to be read in up front and...
Definition: SampleProfReader.h:706
llvm::sampleprof::SampleProfileReaderItaniumRemapper::create
static ErrorOr< std::unique_ptr< SampleProfileReaderItaniumRemapper > > create(const std::string Filename, SampleProfileReader &Reader, LLVMContext &C)
Create a remapper from the given remapping file.
Definition: SampleProfReader.cpp:1649
llvm::sampleprof::SampleProfileReaderExtBinary::SampleProfileReaderExtBinary
SampleProfileReaderExtBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Ext_Binary)
Definition: SampleProfReader.h:760
llvm
Definition: AllocatorList.h:23
llvm::sampleprof::SampleProfileReader::M
const Module * M
The current module being compiled if SampleProfileReader is used by compiler.
Definition: SampleProfReader.h:538
llvm::sampleprof::SampleProfileReader::Remapper
std::unique_ptr< SampleProfileReaderItaniumRemapper > Remapper
Definition: SampleProfReader.h:518
Optional.h
llvm::sampleprof::SampleProfileReaderExtBinaryBase::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:742
llvm::sampleprof::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines the basic structure of the ...
Definition: SampleProfReader.h:667
llvm::sampleprof::SampleProfileReaderBinary::SampleProfileReaderBinary
SampleProfileReaderBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Definition: SampleProfReader.h:562
llvm::sampleprof::SampleProfileReaderGCC::readFunctionProfiles
std::error_code readFunctionProfiles()
Definition: SampleProfReader.cpp:1406
llvm::sampleprof::SampleProfileReader::profileIsProbeBased
bool profileIsProbeBased() const
Whether input profile is based on pseudo probes.
Definition: SampleProfReader.h:465
llvm::Function
Definition: Function.h:61
llvm::sampleprof::SampleProfileReaderGCC::readSectionTag
std::error_code readSectionTag(uint32_t Expected)
Read the section tag and check that it's the same as Expected.
Definition: SampleProfReader.cpp:1374
ProfileSummary.h
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::sampleprof::SecHdrTableEntry
Definition: SampleProf.h:152
llvm::sampleprof::SampleProfileReaderRawBinary::SampleProfileReaderRawBinary
SampleProfileReaderRawBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Binary)
Definition: SampleProfReader.h:640
llvm::sampleprof::SampleProfileReaderBinary::readProfile
std::error_code readProfile(FunctionSamples &FProfile)
Read the contents of the given profile instance.
Definition: SampleProfReader.cpp:490
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1167
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format)
Definition: SampleProfReader.h:724
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SecHdrTable
std::vector< SecHdrTableEntry > SecHdrTable
Definition: SampleProfReader.h:677
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable() override
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:453
llvm::sampleprof::SampleProfileReaderGCC::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Definition: SampleProfReader.cpp:1562
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readNameTableSec
std::error_code readNameTableSec(bool IsMD5)
Definition: SampleProfReader.cpp:980
llvm::sampleprof::SampleProfileReaderGCC::GcovBuffer
GCOVBuffer GcovBuffer
GCOV buffer containing the profile.
Definition: SampleProfReader.h:846
llvm::sampleprof::SampleProfileReaderItaniumRemapper::applyRemapping
void applyRemapping(LLVMContext &Ctx)
Apply remappings to the profile read by Reader.
Definition: SampleProfReader.cpp:1567
Discriminator.h
llvm::sampleprof::SPF_GCC
@ SPF_GCC
Definition: SampleProf.h:91
llvm::sampleprof::SampleProfileReaderExtBinaryBase::verifySPMagic
virtual std::error_code verifySPMagic(uint64_t Magic) override=0
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::getN1Bits
static unsigned getN1Bits(int N)
Definition: Discriminator.h:123
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readCustomSection
virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry)=0
llvm::sampleprof::SampleProfileReaderGCC::readNameTable
std::error_code readNameTable()
Definition: SampleProfReader.cpp:1388
llvm::sampleprof::SampleProfileReaderGCC::Names
std::vector< std::string > Names
Function names in this profile.
Definition: SampleProfReader.h:849
llvm::sampleprof::SampleProfileReaderText::SampleProfileReaderText
SampleProfileReaderText(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:547
llvm::Optional
Definition: APInt.h:33
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readMD5NameTable
std::error_code readMD5NameTable()
Definition: SampleProfReader.cpp:950
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTableEntry
std::error_code readSecHdrTableEntry(uint32_t Idx)
Definition: SampleProfReader.cpp:1032
llvm::sampleprof::HIST_TYPE_IOR
@ HIST_TYPE_IOR
Definition: SampleProfReader.h:814
llvm::sampleprof::SampleProfileReader::collectFuncsFromModule
virtual bool collectFuncsFromModule()
Collect functions with definitions in Module M.
Definition: SampleProfReader.h:390
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::sampleprof::SampleProfileReader::getRemapper
SampleProfileReaderItaniumRemapper * getRemapper()
Definition: SampleProfReader.h:488
llvm::sampleprof::SPF_None
@ SPF_None
Definition: SampleProf.h:88
llvm::sampleprof::SampleProfileReader::Summary
std::unique_ptr< ProfileSummary > Summary
Profile summary information.
Definition: SampleProfReader.h:507
llvm::sampleprof::SampleProfileReaderGCC::readOneFunctionProfile
std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack, bool Update, uint32_t Offset)
Definition: SampleProfReader.cpp:1423
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:50
llvm::sampleprof::SPF_Binary
@ SPF_Binary
Definition: SampleProf.h:93
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::sampleprof::SampleProfileReaderGCC::readNumber
ErrorOr< T > readNumber()
Definition: SampleProfReader.cpp:1330
llvm::sampleprof::SampleProfileReaderBinary::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable()
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:445
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
llvm::sampleprof::FSDiscriminatorPass
FSDiscriminatorPass
Definition: Discriminator.h:57
llvm::sampleprof::HIST_TYPE_INDIR_CALL
@ HIST_TYPE_INDIR_CALL
Definition: SampleProfReader.h:812
llvm::sampleprof::SampleProfileReader::getDiscriminatorMask
uint32_t getDiscriminatorMask() const
Get the bitmask the discriminators: For FS profiles, return the bit mask for this pass.
Definition: SampleProfReader.h:363
llvm::sampleprof::SampleProfileReaderBinary::NameTable
std::vector< StringRef > NameTable
Function name table.
Definition: SampleProfReader.h:625
llvm::sampleprof::SampleProfileReader::takeSummary
static std::unique_ptr< ProfileSummary > takeSummary(SampleProfileReader &Reader)
Take ownership of the summary of this reader.
Definition: SampleProfReader.h:511
llvm::sampleprof::SampleProfileReader::profileIsCS
bool profileIsCS() const
Whether input profile is fully context-sensitive.
Definition: SampleProfReader.h:468
llvm::sampleprof::SampleProfileFormat
SampleProfileFormat
Definition: SampleProf.h:87
llvm::sampleprof::getRepInFormat
static StringRef getRepInFormat(StringRef Name, bool UseMD5, std::string &GUIDBuf)
Get the proper representation of a string according to whether the current Format uses MD5 to represe...
Definition: SampleProf.h:105
llvm::sampleprof::SampleProfileReaderCompactBinary::readImpl
std::error_code readImpl() override
Read samples only for functions to use.
Definition: SampleProfReader.cpp:883
llvm::sampleprof::SampleProfileReaderRawBinary::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Definition: SampleProfReader.cpp:1302
llvm::sampleprof::SampleProfileReader::read
std::error_code read()
The interface to read sample profiles from the associated file.
Definition: SampleProfReader.h:371
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::sampleprof::SampleProfileReader::getSamplesFor
virtual FunctionSamples * getSamplesFor(StringRef Fname)
Return the samples collected for function F.
Definition: SampleProfReader.h:414
GCOV.h
llvm::sampleprof::SampleProfileReaderBinary::readFuncProfile
std::error_code readFuncProfile(const uint8_t *Start)
Read the next function profile instance.
Definition: SampleProfReader.cpp:573
SampleProf.h
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::sampleprof::SampleProfileReaderItaniumRemapper::lookUpNameInProfile
Optional< StringRef > lookUpNameInProfile(StringRef FunctionName)
Return the equivalent name in the profile for FunctionName if it exists.
Definition: SampleProfReader.cpp:1594
llvm::sampleprof::SampleProfileReaderBinary::readString
ErrorOr< StringRef > readString()
Read a string from the profile.
Definition: SampleProfReader.cpp:406
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList() override
Definition: SampleProfReader.h:744
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:50
llvm::sampleprof::SampleProfileReader::readHeader
virtual std::error_code readHeader()=0
Read and validate the file header.
llvm::sampleprof::SampleProfileReader::getBuffer
MemoryBuffer * getBuffer() const
Definition: SampleProfReader.h:459
StringMap.h
llvm::sampleprof::SampleProfileReaderText::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Definition: SampleProfReader.cpp:369
llvm::sampleprof::SampleProfileReaderExtBinaryBase::setSkipFlatProf
virtual void setSkipFlatProf(bool Skip) override
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:748
llvm::sampleprof::SampleProfileReader::getNameTable
virtual std::vector< StringRef > * getNameTable()
It includes all the names that have samples either in outline instance or inline instance.
Definition: SampleProfReader.h:476
llvm::StringMap
StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...
Definition: StringMap.h:108
llvm::sampleprof::HIST_TYPE_CONST_DELTA
@ HIST_TYPE_CONST_DELTA
Definition: SampleProfReader.h:811
llvm::sampleprof::SampleProfileReaderItaniumRemapper::exist
bool exist(StringRef FunctionName)
Query whether there is equivalent in the remapper which has been inserted.
Definition: SampleProfReader.h:293
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
SymbolRemappingReader.h
llvm::sampleprof::SPF_Compact_Binary
@ SPF_Compact_Binary
Definition: SampleProf.h:90
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTable
std::error_code readSecHdrTable()
Definition: SampleProfReader.cpp:1059
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getSectionSize
uint64_t getSectionSize(SecType Type)
Get the total size of all Type sections.
Definition: SampleProfReader.cpp:1086
llvm::sampleprof::SampleProfileReader::getSamplesFor
FunctionSamples * getSamplesFor(const Function &F)
Return the samples collected for function F.
Definition: SampleProfReader.h:396
llvm::sampleprof::SampleProfileReaderItaniumRemapper::insert
void insert(StringRef FunctionName)
Insert function name into remapper.
Definition: SampleProfReader.h:289
llvm::sampleprof::SampleProfileReaderGCC
Definition: SampleProfReader.h:818
llvm::sampleprof::FunctionSamples
Representation of the samples collected for a function.
Definition: SampleProf.h:533
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:67
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::sampleprof::SampleProfileReaderExtBinaryBase::ProfSymList
std::unique_ptr< ProfileSymbolList > ProfSymList
Definition: SampleProfReader.h:696
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFileNames
static const uint32_t GCOVTagAFDOFileNames
GCOV tags used to separate sections in the profile file.
Definition: SampleProfReader.h:852
llvm::sampleprof::SampleProfileReaderExtBinaryBase::MD5StringBuf
std::unique_ptr< std::vector< std::string > > MD5StringBuf
If MD5 is used in NameTable section, the section saves uint64_t data.
Definition: SampleProfReader.h:717
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::sampleprof::SampleProfileReader::SampleProfileReader
SampleProfileReader(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Definition: SampleProfReader.h:345
llvm::sampleprof::SPF_Ext_Binary
@ SPF_Ext_Binary
Definition: SampleProf.h:92
llvm::sampleprof::SampleProfileReaderGCC::SampleProfileReaderGCC
SampleProfileReaderGCC(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:820
llvm::DenseMap
Definition: DenseMap.h:714
ErrorOr.h
llvm::sampleprof::SampleProfileReader::Format
SampleProfileFormat Format
The format of sample.
Definition: SampleProfReader.h:533
llvm::sampleprof::SampleProfileReader::~SampleProfileReader
virtual ~SampleProfileReader()=default
llvm::sampleprof::SampleProfileReaderItaniumRemapper::SampleProfileReaderItaniumRemapper
SampleProfileReaderItaniumRemapper(std::unique_ptr< MemoryBuffer > B, std::unique_ptr< SymbolRemappingReader > SRR, SampleProfileReader &R)
Definition: SampleProfReader.h:264
Magic
const char Magic[]
Definition: Archive.cpp:41
llvm::sampleprof::SampleProfileReader::MaskedBitFrom
uint32_t MaskedBitFrom
Zero out the discriminator bits higher than bit MaskedBitFrom (0 based).
Definition: SampleProfReader.h:542
llvm::ProfileSummary
Definition: ProfileSummary.h:45
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::move
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1540
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncMetadata
std::error_code readFuncMetadata(bool ProfileHasAttribute)
Definition: SampleProfReader.cpp:987
llvm::sampleprof::HIST_TYPE_AVERAGE
@ HIST_TYPE_AVERAGE
Definition: SampleProfReader.h:813
llvm::sampleprof::FunctionSamples::UseMD5
static bool UseMD5
Whether the profile uses MD5 to represent string.
Definition: SampleProf.h:892
llvm::sampleprof::SampleProfileReaderGCC::readString
ErrorOr< StringRef > readString()
Definition: SampleProfReader.cpp:1346
llvm::sampleprof::SampleProfileReader::create
static ErrorOr< std::unique_ptr< SampleProfileReader > > create(const std::string Filename, LLVMContext &C, FSDiscriminatorPass P=FSDiscriminatorPass::Base, const std::string RemapFilename="")
Create a sample profile reader appropriate to the file format.
Definition: SampleProfReader.cpp:1629
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::sampleprof::SampleProfileReader::setSkipFlatProf
virtual void setSkipFlatProf(bool Skip)
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:484
llvm::DiagnosticInfoSampleProfile
Diagnostic information for the sample profiler.
Definition: DiagnosticInfo.h:285
llvm::sampleprof::SampleProfileReaderExtBinary
Definition: SampleProfReader.h:751
llvm::sampleprof::SampleProfileReaderBinary::readMagicIdent
std::error_code readMagicIdent()
Read the contents of Magic number and Version number.
Definition: SampleProfReader.cpp:1165
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFunction
static const uint32_t GCOVTagAFDOFunction
Definition: SampleProfReader.h:853
llvm::sampleprof::SampleProfileReaderBinary::End
const uint8_t * End
Points to the end of the buffer.
Definition: SampleProfReader.h:622
llvm::sampleprof::SampleProfileReaderCompactBinary
Definition: SampleProfReader.h:768
llvm::sampleprof::SampleProfileReader::hasUniqSuffix
virtual bool hasUniqSuffix()
Return whether any name in the profile contains ".__uniq." suffix.
Definition: SampleProfReader.h:486
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readImpl
std::error_code readImpl() override
Read sample profiles in extensible format from the associated file.
Definition: SampleProfReader.cpp:837
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::sampleprof::SampleProfileReader::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList()
Definition: SampleProfReader.h:470
uint32_t
llvm::sampleprof::SampleProfileReaderText::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.h:551
llvm::sampleprof::SampleProfileReader::reportError
void reportError(int64_t LineNumber, const Twine &Msg) const
Report a parse error message.
Definition: SampleProfReader.h:435
llvm::sampleprof::SPF_Text
@ SPF_Text
Definition: SampleProf.h:89
llvm::sampleprof::SampleProfileReader::computeSummary
void computeSummary()
Compute summary for this profile.
Definition: SampleProfReader.cpp:1739
llvm::sampleprof::HIST_TYPE_INTERVAL
@ HIST_TYPE_INTERVAL
Definition: SampleProfReader.h:808
llvm::sampleprof::SampleProfileReader::getFormat
SampleProfileFormat getFormat() const
Return the profile format.
Definition: SampleProfReader.h:462
llvm::sampleprof::SampleProfileReaderBinary::getNameTable
virtual std::vector< StringRef > * getNameTable() override
It includes all the names that have samples either in outline instance or inline instance.
Definition: SampleProfReader.h:574
llvm::sampleprof::SampleProfileReader::getSummary
ProfileSummary & getSummary() const
Return the profile summary.
Definition: SampleProfReader.h:457
llvm::sampleprof::SampleProfileReaderRawBinary
Definition: SampleProfReader.h:635
llvm::LLVMContext::diagnose
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
Definition: LLVMContext.cpp:228
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
std
Definition: BitVector.h:838
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncOffsetTable
DenseMap< StringRef, uint64_t > FuncOffsetTable
The table mapping from function name to the offset of its FunctionSample towards file start.
Definition: SampleProfReader.h:700
llvm::sampleprof::SampleProfileReader::getOrCreateSamplesFor
FunctionSamples * getOrCreateSamplesFor(const Function &F)
Return the samples collected for function F, create empty FunctionSamples if it doesn't exist.
Definition: SampleProfReader.h:406
get
Should compile to something r4 addze r3 instead we get
Definition: README.txt:24
llvm::sampleprof::SampleProfileReaderGCC::skipNextWord
std::error_code skipNextWord()
Definition: SampleProfReader.cpp:1323
llvm::sampleprof::SampleProfileReader::readImpl
virtual std::error_code readImpl()=0
The implementaion to read sample profiles from the associated file.
llvm::sampleprof::SampleProfileReaderBinary::readSummary
std::error_code readSummary()
Read profile summary.
Definition: SampleProfReader.cpp:1264
llvm::sampleprof::SampleProfileReaderGCC::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1353
llvm::sampleprof::SampleProfileReaderCompactBinary::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:800
llvm::sampleprof::SampleProfileReader::getProfiles
StringMap< FunctionSamples > & getProfiles()
Return all the profiles.
Definition: SampleProfReader.h:432
llvm::sampleprof::HIST_TYPE_SINGLE_VALUE
@ HIST_TYPE_SINGLE_VALUE
Definition: SampleProfReader.h:810
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncsToUse
DenseSet< StringRef > FuncsToUse
The set containing the functions to use when compiling a module.
Definition: SampleProfReader.h:702
DiagnosticInfo.h
Function.h
llvm::sampleprof::SecType
SecType
Definition: SampleProf.h:118
llvm::sampleprof::SampleProfileReader
Sample-based profile reader.
Definition: SampleProfReader.h:343
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getFileSize
uint64_t getFileSize()
Get the total size of header and all sections.
Definition: SampleProfReader.cpp:1095
llvm::sampleprof::SampleProfileReaderExtBinaryBase::MD5NameMemStart
const uint8_t * MD5NameMemStart
The starting address of NameTable containing fixed length MD5.
Definition: SampleProfReader.h:708
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readHeader
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1071
llvm::sampleprof::SampleProfileReader::setModule
void setModule(const Module *Mod)
Definition: SampleProfReader.h:490
llvm::sampleprof::HIST_TYPE_INDIR_CALL_TOPN
@ HIST_TYPE_INDIR_CALL_TOPN
Definition: SampleProfReader.h:815
llvm::sampleprof_error::success
@ success
llvm::sampleprof::SampleProfileReaderBinary::readUnencodedNumber
ErrorOr< T > readUnencodedNumber()
Read a numeric value of type T from the profile.
Definition: SampleProfReader.cpp:420
llvm::sampleprof::FunctionSamples::getCanonicalFnName
static StringRef getCanonicalFnName(const Function &F)
Return the canonical name for a function, taking into account suffix elision policy attributes.
Definition: SampleProf.h:793
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SkipFlatProf
bool SkipFlatProf
If SkipFlatProf is true, skip the sections with SecFlagFlat flag.
Definition: SampleProfReader.h:721
llvm::sampleprof::SampleProfileReaderBinary::readNumber
ErrorOr< T > readNumber()
Read a numeric value of type T from the profile.
Definition: SampleProfReader.cpp:385
llvm::sampleprof::SampleProfileReader::dumpSectionInfo
virtual bool dumpSectionInfo(raw_ostream &OS=dbgs())
Definition: SampleProfReader.h:477
llvm::sampleprof::SampleProfileReaderBinary::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:598
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncProfiles
std::error_code readFuncProfiles()
Definition: SampleProfReader.cpp:699
llvm::sampleprof::SampleProfileReader::Ctx
LLVMContext & Ctx
LLVM context used to emit diagnostics.
Definition: SampleProfReader.h:501
SmallVector.h
llvm::sampleprof::SampleProfileReader::dumpFunctionProfile
void dumpFunctionProfile(StringRef FName, raw_ostream &OS=dbgs())
Print the profile for FName on stream OS.
Definition: SampleProfReader.cpp:62
llvm::sampleprof::SampleProfileReaderCompactBinary::collectFuncsFromModule
bool collectFuncsFromModule() override
Collect functions with definitions in Module M.
Definition: SampleProfReader.cpp:1237
llvm::sampleprof::SampleProfileReaderBinary
Definition: SampleProfReader.h:560
llvm::ErrorOr
Represents either an error or a value T.
Definition: ErrorOr.h:56
llvm::sampleprof::SampleProfileReader::useMD5
virtual bool useMD5()
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:480
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readOneSection
virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size, const SecHdrTableEntry &Entry)
Definition: SampleProfReader.cpp:608
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncOffsetTable
std::error_code readFuncOffsetTable()
Definition: SampleProfReader.cpp:674
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readProfileSymbolList
std::error_code readProfileSymbolList()
Definition: SampleProfReader.cpp:797
llvm::sampleprof::SampleProfileReaderItaniumRemapper
SampleProfileReaderItaniumRemapper remaps the profile data from a sample profile data reader,...
Definition: SampleProfReader.h:262
llvm::sampleprof::SampleProfileReaderCompactBinary::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Definition: SampleProfReader.cpp:1316
llvm::sampleprof::SampleProfileReaderItaniumRemapper::hasApplied
bool hasApplied()
Definition: SampleProfReader.h:286
llvm::getFSPassBitEnd
static unsigned getFSPassBitEnd(FSDiscriminatorPass P)
Definition: Discriminator.h:89
llvm::sampleprof::SampleProfileReader::setDiscriminatorMaskedBitFrom
void setDiscriminatorMaskedBitFrom(FSDiscriminatorPass P)
Set the bits for FS discriminators.
Definition: SampleProfReader.h:357
llvm::sampleprof::SampleProfileReader::ProfileIsCS
bool ProfileIsCS
Whether function profiles are context-sensitive.
Definition: SampleProfReader.h:524
LLVMContext.h
llvm::GCOVBuffer
GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations.
Definition: GCOV.h:76
llvm::sampleprof::SampleProfileReaderExtBinaryBase::dumpSectionInfo
virtual bool dumpSectionInfo(raw_ostream &OS=dbgs()) override
Definition: SampleProfReader.cpp:1146
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::sampleprof::HIST_TYPE_POW2
@ HIST_TYPE_POW2
Definition: SampleProfReader.h:809
llvm::sampleprof::SampleProfileReader::Profiles
StringMap< FunctionSamples > Profiles
Map every function to its associated profile.
Definition: SampleProfReader.h:498
llvm::sampleprof::SampleProfileReaderExtBinary::hasFormat
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if Buffer is in the format supported by this class.
Definition: SampleProfReader.cpp:1309
llvm::sampleprof::SampleProfileReaderGCC::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:1549
llvm::sampleprof::SampleProfileReaderBinary::readStringIndex
ErrorOr< uint32_t > readStringIndex(T &Table)
Read the string index and check whether it overflows the table.
Definition: SampleProfReader.cpp:435
llvm::sampleprof::SampleProfileReaderBinary::Data
const uint8_t * Data
Points to the current location in the buffer.
Definition: SampleProfReader.h:619
Debug.h
llvm::sampleprof::SampleProfileReaderBinary::readHeader
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1183
llvm::sampleprof::SampleProfileReader::Buffer
std::unique_ptr< MemoryBuffer > Buffer
Memory buffer holding the profile file.
Definition: SampleProfReader.h:504
llvm::sampleprof::SampleProfileReaderCompactBinary::SampleProfileReaderCompactBinary
SampleProfileReaderCompactBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:785
llvm::sampleprof::HistType
HistType
Definition: SampleProfReader.h:807
llvm::sampleprof::Base
@ Base
Definition: Discriminator.h:58
llvm::sampleprof::SampleProfileReaderExtBinaryBase::collectFuncsFromModule
bool collectFuncsFromModule() override
Collect functions with definitions in Module M.
Definition: SampleProfReader.cpp:665
llvm::sampleprof::SampleProfileReader::ProfileIsProbeBased
bool ProfileIsProbeBased
Whether samples are collected based on pseudo probes.
Definition: SampleProfReader.h:521
llvm::sampleprof::SampleProfileReaderBinary::at_eof
bool at_eof() const
Return true if we've reached the end of file.
Definition: SampleProfReader.h:601