LLVM  16.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/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"
236 #include "llvm/Support/Debug.h"
238 #include "llvm/Support/ErrorOr.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.
262 public:
263  SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B,
264  std::unique_ptr<SymbolRemappingReader> SRR,
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.
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.
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.
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.
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.
343 public:
344  SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
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.
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.
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);
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  /// Print all the profiles on stream \p OS in the JSON format.
395  void dumpJson(raw_ostream &OS = dbgs());
396 
397  /// Return the samples collected for function \p F.
399  // The function name may have been updated by adding suffix. Call
400  // a helper to (optionally) strip off suffixes so that we can
401  // match against the original function name in the profile.
403  return getSamplesFor(CanonName);
404  }
405 
406  /// Return the samples collected for function \p F, create empty
407  /// FunctionSamples if it doesn't exist.
409  std::string FGUID;
411  CanonName = getRepInFormat(CanonName, useMD5(), FGUID);
412  auto It = Profiles.find(CanonName);
413  if (It != Profiles.end())
414  return &It->second;
415  if (!FGUID.empty()) {
416  assert(useMD5() && "New name should only be generated for md5 profile");
417  CanonName = *MD5NameBuffer.insert(FGUID).first;
418  }
419  return &Profiles[CanonName];
420  }
421 
422  /// Return the samples collected for function \p F.
424  std::string FGUID;
425  Fname = getRepInFormat(Fname, useMD5(), FGUID);
426  auto It = Profiles.find(Fname);
427  if (It != Profiles.end())
428  return &It->second;
429 
430  if (Remapper) {
431  if (auto NameInProfile = Remapper->lookUpNameInProfile(Fname)) {
432  auto It = Profiles.find(*NameInProfile);
433  if (It != Profiles.end())
434  return &It->second;
435  }
436  }
437  return nullptr;
438  }
439 
440  /// Return all the profiles.
442 
443  /// Report a parse error message.
444  void reportError(int64_t LineNumber, const Twine &Msg) const {
445  Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
446  LineNumber, Msg));
447  }
448 
449  /// Create a sample profile reader appropriate to the file format.
450  /// Create a remapper underlying if RemapFilename is not empty.
451  /// Parameter P specifies the FSDiscriminatorPass.
453  create(const std::string Filename, LLVMContext &C,
455  const std::string RemapFilename = "");
456 
457  /// Create a sample profile reader from the supplied memory buffer.
458  /// Create a remapper underlying if RemapFilename is not empty.
459  /// Parameter P specifies the FSDiscriminatorPass.
461  create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
463  const std::string RemapFilename = "");
464 
465  /// Return the profile summary.
466  ProfileSummary &getSummary() const { return *(Summary.get()); }
467 
468  MemoryBuffer *getBuffer() const { return Buffer.get(); }
469 
470  /// \brief Return the profile format.
472 
473  /// Whether input profile is based on pseudo probes.
474  bool profileIsProbeBased() const { return ProfileIsProbeBased; }
475 
476  /// Whether input profile is fully context-sensitive.
477  bool profileIsCS() const { return ProfileIsCS; }
478 
479  /// Whether input profile contains ShouldBeInlined contexts.
480  bool profileIsPreInlined() const { return ProfileIsPreInlined; }
481 
482  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
483  return nullptr;
484  };
485 
486  /// It includes all the names that have samples either in outline instance
487  /// or inline instance.
488  virtual std::vector<StringRef> *getNameTable() { return nullptr; }
489  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
490 
491  /// Return whether names in the profile are all MD5 numbers.
492  virtual bool useMD5() { return false; }
493 
494  /// Don't read profile without context if the flag is set. This is only meaningful
495  /// for ExtBinary format.
496  virtual void setSkipFlatProf(bool Skip) {}
497  /// Return whether any name in the profile contains ".__uniq." suffix.
498  virtual bool hasUniqSuffix() { return false; }
499 
501 
502  void setModule(const Module *Mod) { M = Mod; }
503 
504 protected:
505  /// Map every function to its associated profile.
506  ///
507  /// The profile of every function executed at runtime is collected
508  /// in the structure FunctionSamples. This maps function objects
509  /// to their corresponding profiles.
511 
512  /// LLVM context used to emit diagnostics.
514 
515  /// Memory buffer holding the profile file.
516  std::unique_ptr<MemoryBuffer> Buffer;
517 
518  /// Extra name buffer holding names created on demand.
519  /// This should only be needed for md5 profiles.
520  std::unordered_set<std::string> MD5NameBuffer;
521 
522  /// Profile summary information.
523  std::unique_ptr<ProfileSummary> Summary;
524 
525  /// Take ownership of the summary of this reader.
526  static std::unique_ptr<ProfileSummary>
528  return std::move(Reader.Summary);
529  }
530 
531  /// Compute summary for this profile.
532  void computeSummary();
533 
534  std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper;
535 
536  /// \brief Whether samples are collected based on pseudo probes.
537  bool ProfileIsProbeBased = false;
538 
539  /// Whether function profiles are context-sensitive flat profiles.
540  bool ProfileIsCS = false;
541 
542  /// Whether function profile contains ShouldBeInlined contexts.
543  bool ProfileIsPreInlined = false;
544 
545  /// Number of context-sensitive profiles.
547 
548  /// Whether the function profiles use FS discriminators.
549  bool ProfileIsFS = false;
550 
551  /// \brief The format of sample.
553 
554  /// \brief The current module being compiled if SampleProfileReader
555  /// is used by compiler. If SampleProfileReader is used by other
556  /// tools which are not compiler, M is usually nullptr.
557  const Module *M = nullptr;
558 
559  /// Zero out the discriminator bits higher than bit MaskedBitFrom (0 based).
560  /// The default is to keep all the bits.
562 };
563 
565 public:
566  SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
568 
569  /// Read and validate the file header.
570  std::error_code readHeader() override { return sampleprof_error::success; }
571 
572  /// Read sample profiles from the associated file.
573  std::error_code readImpl() override;
574 
575  /// Return true if \p Buffer is in the format supported by this class.
576  static bool hasFormat(const MemoryBuffer &Buffer);
577 
578 private:
579  /// CSNameTable is used to save full context vectors. This serves as an
580  /// underlying immutable buffer for all clients.
581  std::list<SampleContextFrameVector> CSNameTable;
582 };
583 
585 public:
586  SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
589 
590  /// Read and validate the file header.
591  std::error_code readHeader() override;
592 
593  /// Read sample profiles from the associated file.
594  std::error_code readImpl() override;
595 
596  /// It includes all the names that have samples either in outline instance
597  /// or inline instance.
598  std::vector<StringRef> *getNameTable() override { return &NameTable; }
599 
600 protected:
601  /// Read a numeric value of type T from the profile.
602  ///
603  /// If an error occurs during decoding, a diagnostic message is emitted and
604  /// EC is set.
605  ///
606  /// \returns the read value.
607  template <typename T> ErrorOr<T> readNumber();
608 
609  /// Read a numeric value of type T from the profile. The value is saved
610  /// without encoded.
611  template <typename T> ErrorOr<T> readUnencodedNumber();
612 
613  /// Read a string from the profile.
614  ///
615  /// If an error occurs during decoding, a diagnostic message is emitted and
616  /// EC is set.
617  ///
618  /// \returns the read value.
620 
621  /// Read the string index and check whether it overflows the table.
622  template <typename T> inline ErrorOr<uint32_t> readStringIndex(T &Table);
623 
624  /// Return true if we've reached the end of file.
625  bool at_eof() const { return Data >= End; }
626 
627  /// Read the next function profile instance.
628  std::error_code readFuncProfile(const uint8_t *Start);
629 
630  /// Read the contents of the given profile instance.
631  std::error_code readProfile(FunctionSamples &FProfile);
632 
633  /// Read the contents of Magic number and Version number.
634  std::error_code readMagicIdent();
635 
636  /// Read profile summary.
637  std::error_code readSummary();
638 
639  /// Read the whole name table.
640  virtual std::error_code readNameTable();
641 
642  /// Points to the current location in the buffer.
643  const uint8_t *Data = nullptr;
644 
645  /// Points to the end of the buffer.
646  const uint8_t *End = nullptr;
647 
648  /// Function name table.
649  std::vector<StringRef> NameTable;
650 
651  /// Read a string indirectly via the name table.
654 
655 private:
656  std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
657  virtual std::error_code verifySPMagic(uint64_t Magic) = 0;
658 };
659 
661 private:
662  std::error_code verifySPMagic(uint64_t Magic) override;
663 
664 public:
665  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
668 
669  /// \brief Return true if \p Buffer is in the format supported by this class.
670  static bool hasFormat(const MemoryBuffer &Buffer);
671 };
672 
673 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines
674 /// the basic structure of the extensible binary format.
675 /// The format is organized in sections except the magic and version number
676 /// at the beginning. There is a section table before all the sections, and
677 /// each entry in the table describes the entry type, start, size and
678 /// attributes. The format in each section is defined by the section itself.
679 ///
680 /// It is easy to add a new section while maintaining the backward
681 /// compatibility of the profile. Nothing extra needs to be done. If we want
682 /// to extend an existing section, like add cache misses information in
683 /// addition to the sample count in the profile body, we can add a new section
684 /// with the extension and retire the existing section, and we could choose
685 /// to keep the parser of the old section if we want the reader to be able
686 /// to read both new and old format profile.
687 ///
688 /// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the
689 /// commonly used sections of a profile in extensible binary format. It is
690 /// possible to define other types of profile inherited from
691 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase.
693 private:
694  std::error_code decompressSection(const uint8_t *SecStart,
695  const uint64_t SecSize,
696  const uint8_t *&DecompressBuf,
697  uint64_t &DecompressBufSize);
698 
699  BumpPtrAllocator Allocator;
700 
701 protected:
702  std::vector<SecHdrTableEntry> SecHdrTable;
703  std::error_code readSecHdrTableEntry(uint32_t Idx);
704  std::error_code readSecHdrTable();
705 
706  std::error_code readFuncMetadata(bool ProfileHasAttribute);
707  std::error_code readFuncMetadata(bool ProfileHasAttribute,
708  FunctionSamples *FProfile);
709  std::error_code readFuncOffsetTable();
710  std::error_code readFuncProfiles();
711  std::error_code readMD5NameTable();
712  std::error_code readNameTableSec(bool IsMD5);
713  std::error_code readCSNameTableSec();
714  std::error_code readProfileSymbolList();
715 
716  std::error_code readHeader() override;
717  std::error_code verifySPMagic(uint64_t Magic) override = 0;
718  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
719  const SecHdrTableEntry &Entry);
720  // placeholder for subclasses to dispatch their own section readers.
721  virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0;
725 
726  std::unique_ptr<ProfileSymbolList> ProfSymList;
727 
728  /// The table mapping from function context to the offset of its
729  /// FunctionSample towards file start.
731 
732  /// Function offset mapping ordered by contexts.
733  std::unique_ptr<std::vector<std::pair<SampleContext, uint64_t>>>
735 
736  /// The set containing the functions to use when compiling a module.
738 
739  /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
740  /// need to be read in up front and can be directly accessed using index.
741  bool FixedLengthMD5 = false;
742  /// The starting address of NameTable containing fixed length MD5.
743  const uint8_t *MD5NameMemStart = nullptr;
744 
745  /// If MD5 is used in NameTable section, the section saves uint64_t data.
746  /// The uint64_t data has to be converted to a string and then the string
747  /// will be used to initialize StringRef in NameTable.
748  /// Note NameTable contains StringRef so it needs another buffer to own
749  /// the string data. MD5StringBuf serves as the string buffer that is
750  /// referenced by NameTable (vector of StringRef). We make sure
751  /// the lifetime of MD5StringBuf is not shorter than that of NameTable.
752  std::unique_ptr<std::vector<std::string>> MD5StringBuf;
753 
754  /// CSNameTable is used to save full context vectors. This serves as an
755  /// underlying immutable buffer for all clients.
756  std::unique_ptr<const std::vector<SampleContextFrameVector>> CSNameTable;
757 
758  /// If SkipFlatProf is true, skip the sections with
759  /// SecFlagFlat flag.
760  bool SkipFlatProf = false;
761 
762  bool FuncOffsetsOrdered = false;
763 
764 public:
765  SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B,
768 
769  /// Read sample profiles in extensible format from the associated file.
770  std::error_code readImpl() override;
771 
772  /// Get the total size of all \p Type sections.
774  /// Get the total size of header and all sections.
776  bool dumpSectionInfo(raw_ostream &OS = dbgs()) override;
777 
778  /// Collect functions with definitions in Module M. Return true if
779  /// the reader has been given a module.
780  bool collectFuncsFromModule() override;
781 
782  /// Return whether names in the profile are all MD5 numbers.
783  bool useMD5() override { return MD5StringBuf.get(); }
784 
785  std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
786  return std::move(ProfSymList);
787  };
788 
789  void setSkipFlatProf(bool Skip) override { SkipFlatProf = Skip; }
790 };
791 
793 private:
794  std::error_code verifySPMagic(uint64_t Magic) override;
795  std::error_code readCustomSection(const SecHdrTableEntry &Entry) override {
796  // Update the data reader pointer to the end of the section.
797  Data = End;
799  };
800 
801 public:
802  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
805 
806  /// \brief Return true if \p Buffer is in the format supported by this class.
807  static bool hasFormat(const MemoryBuffer &Buffer);
808 };
809 
811 private:
812  /// Function name table.
813  std::vector<std::string> NameTable;
814  /// The table mapping from function name to the offset of its FunctionSample
815  /// towards file start.
816  DenseMap<StringRef, uint64_t> FuncOffsetTable;
817  /// The set containing the functions to use when compiling a module.
818  DenseSet<StringRef> FuncsToUse;
819  std::error_code verifySPMagic(uint64_t Magic) override;
820  std::error_code readNameTable() override;
821  /// Read a string indirectly via the name table.
822  ErrorOr<StringRef> readStringFromTable() override;
823  std::error_code readHeader() override;
824  std::error_code readFuncOffsetTable();
825 
826 public:
827  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
828  LLVMContext &C)
830 
831  /// \brief Return true if \p Buffer is in the format supported by this class.
832  static bool hasFormat(const MemoryBuffer &Buffer);
833 
834  /// Read samples only for functions to use.
835  std::error_code readImpl() override;
836 
837  /// Collect functions with definitions in Module M. Return true if
838  /// the reader has been given a module.
839  bool collectFuncsFromModule() override;
840 
841  /// Return whether names in the profile are all MD5 numbers.
842  bool useMD5() override { return true; }
843 };
844 
846 
847 // Supported histogram types in GCC. Currently, we only need support for
848 // call target histograms.
849 enum HistType {
858 };
859 
861 public:
862  SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
864  GcovBuffer(Buffer.get()) {}
865 
866  /// Read and validate the file header.
867  std::error_code readHeader() override;
868 
869  /// Read sample profiles from the associated file.
870  std::error_code readImpl() override;
871 
872  /// Return true if \p Buffer is in the format supported by this class.
873  static bool hasFormat(const MemoryBuffer &Buffer);
874 
875 protected:
876  std::error_code readNameTable();
877  std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack,
878  bool Update, uint32_t Offset);
879  std::error_code readFunctionProfiles();
880  std::error_code skipNextWord();
881  template <typename T> ErrorOr<T> readNumber();
883 
884  /// Read the section tag and check that it's the same as \p Expected.
885  std::error_code readSectionTag(uint32_t Expected);
886 
887  /// GCOV buffer containing the profile.
889 
890  /// Function names in this profile.
891  std::vector<std::string> Names;
892 
893  /// GCOV tags used to separate sections in the profile file.
894  static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
895  static const uint32_t GCOVTagAFDOFunction = 0xac000000;
896 };
897 
898 } // end namespace sampleprof
899 
900 } // end namespace llvm
901 
902 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H
llvm::sampleprof::SampleProfileReader::ProfileIsFS
bool ProfileIsFS
Whether the function profiles use FS discriminators.
Definition: SampleProfReader.h:549
MemoryBuffer.h
llvm::sampleprof::SampleProfileReader::dump
void dump(raw_ostream &OS=dbgs())
Print all the profiles on stream OS.
Definition: SampleProfReader.cpp:69
llvm::sampleprof::SampleProfileReaderText
Definition: SampleProfReader.h:564
llvm::sampleprof::SampleProfileReaderBinary::readNameTable
virtual std::error_code readNameTable()
Read the whole name table.
Definition: SampleProfReader.cpp:1066
llvm::sampleprof::SampleProfileReader::CSProfileCount
uint32_t CSProfileCount
Number of context-sensitive profiles.
Definition: SampleProfReader.h:546
llvm::sampleprof::SampleProfileReaderText::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:316
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:741
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:1879
llvm::sampleprof::SampleProfileReaderExtBinary::SampleProfileReaderExtBinary
SampleProfileReaderExtBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Ext_Binary)
Definition: SampleProfReader.h:802
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
llvm::sampleprof::SampleProfileReader::M
const Module * M
The current module being compiled if SampleProfileReader is used by compiler.
Definition: SampleProfReader.h:557
llvm::sampleprof::SampleProfileReaderExtBinaryBase::setSkipFlatProf
void setSkipFlatProf(bool Skip) override
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:789
llvm::sampleprof::SampleProfileReader::Remapper
std::unique_ptr< SampleProfileReaderItaniumRemapper > Remapper
Definition: SampleProfReader.h:534
Optional.h
llvm::sampleprof::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines the basic structure of the ...
Definition: SampleProfReader.h:692
llvm::sampleprof::SampleProfileReaderBinary::SampleProfileReaderBinary
SampleProfileReaderBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Definition: SampleProfReader.h:586
llvm::sampleprof::SampleProfileReaderGCC::readFunctionProfiles
std::error_code readFunctionProfiles()
Definition: SampleProfReader.cpp:1636
llvm::sampleprof::SampleProfileReader::profileIsProbeBased
bool profileIsProbeBased() const
Whether input profile is based on pseudo probes.
Definition: SampleProfReader.h:474
llvm::Function
Definition: Function.h:60
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:1604
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:159
llvm::sampleprof::SampleProfileReaderRawBinary::SampleProfileReaderRawBinary
SampleProfileReaderRawBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Binary)
Definition: SampleProfReader.h:665
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readCSNameTableSec
std::error_code readCSNameTableSec()
Definition: SampleProfReader.cpp:1121
llvm::sampleprof::SampleProfileReaderBinary::readProfile
std::error_code readProfile(FunctionSamples &FProfile)
Read the contents of the given profile instance.
Definition: SampleProfReader.cpp:578
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readContextFromTable
ErrorOr< SampleContextFrames > readContextFromTable()
Definition: SampleProfReader.cpp:696
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format)
Definition: SampleProfReader.h:765
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SecHdrTable
std::vector< SecHdrTableEntry > SecHdrTable
Definition: SampleProfReader.h:702
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readStringFromTable
ErrorOr< StringRef > readStringFromTable() override
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:541
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:1792
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readNameTableSec
std::error_code readNameTableSec(bool IsMD5)
Definition: SampleProfReader.cpp:1111
llvm::sampleprof::SampleProfileReaderGCC::GcovBuffer
GCOVBuffer GcovBuffer
GCOV buffer containing the profile.
Definition: SampleProfReader.h:888
llvm::sampleprof::SampleProfileMap
std::unordered_map< SampleContext, FunctionSamples, SampleContext::Hash > SampleProfileMap
Definition: SampleProf.h:1199
llvm::sampleprof::SampleProfileReaderItaniumRemapper::applyRemapping
void applyRemapping(LLVMContext &Ctx)
Apply remappings to the profile read by Reader.
Definition: SampleProfReader.cpp:1797
Discriminator.h
llvm::sampleprof::SPF_GCC
@ SPF_GCC
Definition: SampleProf.h:94
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::getN1Bits
static unsigned getN1Bits(int N)
Definition: Discriminator.h:123
llvm::sampleprof::SampleProfileReaderExtBinaryBase::CSNameTable
std::unique_ptr< const std::vector< SampleContextFrameVector > > CSNameTable
CSNameTable is used to save full context vectors.
Definition: SampleProfReader.h:756
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readCustomSection
virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry)=0
llvm::sampleprof::SampleProfileReaderGCC::readNameTable
std::error_code readNameTable()
Definition: SampleProfReader.cpp:1618
llvm::sampleprof::SampleProfileReaderGCC::Names
std::vector< std::string > Names
Function names in this profile.
Definition: SampleProfReader.h:891
llvm::sampleprof::SampleProfileReaderText::SampleProfileReaderText
SampleProfileReaderText(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:566
llvm::Optional
Definition: APInt.h:33
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readMD5NameTable
std::error_code readMD5NameTable()
Definition: SampleProfReader.cpp:1081
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncOffsetsOrdered
bool FuncOffsetsOrdered
Definition: SampleProfReader.h:762
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTableEntry
std::error_code readSecHdrTableEntry(uint32_t Idx)
Definition: SampleProfReader.cpp:1250
llvm::sampleprof::HIST_TYPE_IOR
@ HIST_TYPE_IOR
Definition: SampleProfReader.h:856
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSampleContextFromTable
ErrorOr< SampleContext > readSampleContextFromTable() override
Definition: SampleProfReader.cpp:706
llvm::sampleprof::SampleProfileReader::collectFuncsFromModule
virtual bool collectFuncsFromModule()
Collect functions with definitions in Module M.
Definition: SampleProfReader.h:389
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:41
llvm::sampleprof::SampleProfileReader::getRemapper
SampleProfileReaderItaniumRemapper * getRemapper()
Definition: SampleProfReader.h:500
llvm::sampleprof::SPF_None
@ SPF_None
Definition: SampleProf.h:91
llvm::sampleprof::SampleProfileReader::Summary
std::unique_ptr< ProfileSummary > Summary
Profile summary information.
Definition: SampleProfReader.h:523
llvm::sampleprof::SampleProfileReaderGCC::readOneFunctionProfile
std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack, bool Update, uint32_t Offset)
Definition: SampleProfReader.cpp:1653
llvm::MemoryBuffer
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
llvm::sampleprof::SPF_Binary
@ SPF_Binary
Definition: SampleProf.h:96
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::sampleprof::SampleProfileReaderGCC::readNumber
ErrorOr< T > readNumber()
Definition: SampleProfReader.cpp:1560
llvm::sampleprof::SampleProfileReaderBinary::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable()
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:526
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::sampleprof::FSDiscriminatorPass
FSDiscriminatorPass
Definition: Discriminator.h:57
llvm::sampleprof::HIST_TYPE_INDIR_CALL
@ HIST_TYPE_INDIR_CALL
Definition: SampleProfReader.h:854
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:362
llvm::sampleprof::SampleProfileReaderBinary::NameTable
std::vector< StringRef > NameTable
Function name table.
Definition: SampleProfReader.h:649
llvm::sampleprof::SampleProfileReader::takeSummary
static std::unique_ptr< ProfileSummary > takeSummary(SampleProfileReader &Reader)
Take ownership of the summary of this reader.
Definition: SampleProfReader.h:527
llvm::sampleprof::SampleProfileReader::profileIsCS
bool profileIsCS() const
Whether input profile is fully context-sensitive.
Definition: SampleProfReader.h:477
llvm::sampleprof::SampleProfileFormat
SampleProfileFormat
Definition: SampleProf.h:90
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:108
llvm::sampleprof::SampleProfileReaderCompactBinary::readImpl
std::error_code readImpl() override
Read samples only for functions to use.
Definition: SampleProfReader.cpp:1013
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:1532
llvm::sampleprof::SampleProfileReader::read
std::error_code read()
The interface to read sample profiles from the associated file.
Definition: SampleProfReader.h:370
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:423
GCOV.h
llvm::sampleprof::SampleProfileReaderBinary::readFuncProfile
std::error_code readFuncProfile(const uint8_t *Start)
Read the next function profile instance.
Definition: SampleProfReader.cpp:661
llvm::sampleprof::SampleProfileReader::MD5NameBuffer
std::unordered_set< std::string > MD5NameBuffer
Extra name buffer holding names created on demand.
Definition: SampleProfReader.h:520
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:1824
llvm::sampleprof::SampleProfileReaderExtBinaryBase::verifySPMagic
std::error_code verifySPMagic(uint64_t Magic) override=0
llvm::sampleprof::SampleProfileReaderBinary::readString
ErrorOr< StringRef > readString()
Read a string from the profile.
Definition: SampleProfReader.cpp:487
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::sampleprof::SampleProfileReader::readHeader
virtual std::error_code readHeader()=0
Read and validate the file header.
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncOffsetTable
DenseMap< SampleContext, uint64_t > FuncOffsetTable
The table mapping from function context to the offset of its FunctionSample towards file start.
Definition: SampleProfReader.h:730
llvm::sampleprof::SampleProfileReader::getBuffer
MemoryBuffer * getBuffer() const
Definition: SampleProfReader.h:468
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:450
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:488
llvm::sampleprof::SampleContext
Definition: SampleProf.h:509
llvm::sampleprof::HIST_TYPE_CONST_DELTA
@ HIST_TYPE_CONST_DELTA
Definition: SampleProfReader.h:853
llvm::sampleprof::SampleProfileReaderItaniumRemapper::exist
bool exist(StringRef FunctionName)
Query whether there is equivalent in the remapper which has been inserted.
Definition: SampleProfReader.h:292
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:93
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTable
std::error_code readSecHdrTable()
Definition: SampleProfReader.cpp:1277
uint64_t
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getSectionSize
uint64_t getSectionSize(SecType Type)
Get the total size of all Type sections.
Definition: SampleProfReader.cpp:1304
llvm::sampleprof::SampleProfileReader::getSamplesFor
FunctionSamples * getSamplesFor(const Function &F)
Return the samples collected for function F.
Definition: SampleProfReader.h:398
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getProfileSymbolList
std::unique_ptr< ProfileSymbolList > getProfileSymbolList() override
Definition: SampleProfReader.h:785
llvm::sampleprof::SampleProfileReaderItaniumRemapper::insert
void insert(StringRef FunctionName)
Insert function name into remapper.
Definition: SampleProfReader.h:288
llvm::sampleprof::SampleProfileReaderGCC
Definition: SampleProfReader.h:860
llvm::sampleprof::FunctionSamples
Representation of the samples collected for a function.
Definition: SampleProf.h:718
llvm::BumpPtrAllocatorImpl
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:63
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:726
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFileNames
static const uint32_t GCOVTagAFDOFileNames
GCOV tags used to separate sections in the profile file.
Definition: SampleProfReader.h:894
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:752
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
llvm::sampleprof::SampleProfileReader::SampleProfileReader
SampleProfileReader(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Definition: SampleProfReader.h:344
llvm::sampleprof::SPF_Ext_Binary
@ SPF_Ext_Binary
Definition: SampleProf.h:95
llvm::sampleprof::SampleProfileReaderGCC::SampleProfileReaderGCC
SampleProfileReaderGCC(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:862
llvm::DenseMap
Definition: DenseMap.h:714
ErrorOr.h
llvm::sampleprof::SampleProfileReader::Format
SampleProfileFormat Format
The format of sample.
Definition: SampleProfReader.h:552
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:263
llvm::sampleprof::SampleProfileReader::MaskedBitFrom
uint32_t MaskedBitFrom
Zero out the discriminator bits higher than bit MaskedBitFrom (0 based).
Definition: SampleProfReader.h:561
llvm::ProfileSummary
Definition: ProfileSummary.h:45
llvm::sampleprof::SampleProfileReaderBinary::readSampleContextFromTable
virtual ErrorOr< SampleContext > readSampleContextFromTable()
Definition: SampleProfReader.cpp:534
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::sampleprof::SampleProfileReader::ProfileIsPreInlined
bool ProfileIsPreInlined
Whether function profile contains ShouldBeInlined contexts.
Definition: SampleProfReader.h:543
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:1861
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncMetadata
std::error_code readFuncMetadata(bool ProfileHasAttribute)
Definition: SampleProfReader.cpp:1217
llvm::sampleprof::HIST_TYPE_AVERAGE
@ HIST_TYPE_AVERAGE
Definition: SampleProfReader.h:855
llvm::sampleprof::FunctionSamples::UseMD5
static bool UseMD5
Whether the profile uses MD5 to represent string.
Definition: SampleProf.h:1129
llvm::sampleprof::SampleProfileReaderGCC::readString
ErrorOr< StringRef > readString()
Definition: SampleProfReader.cpp:1576
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:1859
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::sampleprof::SampleProfileReader::setSkipFlatProf
virtual void setSkipFlatProf(bool Skip)
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:496
llvm::DiagnosticInfoSampleProfile
Diagnostic information for the sample profiler.
Definition: DiagnosticInfo.h:235
llvm::sampleprof::SampleProfileReaderExtBinary
Definition: SampleProfReader.h:792
llvm::sampleprof::SampleProfileReaderBinary::readMagicIdent
std::error_code readMagicIdent()
Read the contents of Magic number and Version number.
Definition: SampleProfReader.cpp:1395
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFunction
static const uint32_t GCOVTagAFDOFunction
Definition: SampleProfReader.h:895
llvm::sampleprof::SampleProfileReaderBinary::End
const uint8_t * End
Points to the end of the buffer.
Definition: SampleProfReader.h:646
llvm::sampleprof::SampleProfileReaderCompactBinary
Definition: SampleProfReader.h:810
llvm::sampleprof::SampleProfileReader::hasUniqSuffix
virtual bool hasUniqSuffix()
Return whether any name in the profile contains ".__uniq." suffix.
Definition: SampleProfReader.h:498
llvm::sampleprof::SampleProfileReaderBinary::getNameTable
std::vector< StringRef > * getNameTable() override
It includes all the names that have samples either in outline instance or inline instance.
Definition: SampleProfReader.h:598
llvm::sampleprof::SampleProfileReaderCompactBinary::useMD5
bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:842
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readImpl
std::error_code readImpl() override
Read sample profiles in extensible format from the associated file.
Definition: SampleProfReader.cpp:967
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm::msf::Magic
static const char Magic[]
Definition: MSFCommon.h:23
llvm::sampleprof::SampleProfileReader::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList()
Definition: SampleProfReader.h:482
llvm::sampleprof::SampleProfileReaderExtBinaryBase::useMD5
bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:783
uint32_t
llvm::sampleprof::SampleProfileReaderText::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.h:570
llvm::sampleprof::SampleProfileReader::reportError
void reportError(int64_t LineNumber, const Twine &Msg) const
Report a parse error message.
Definition: SampleProfReader.h:444
llvm::sampleprof::SPF_Text
@ SPF_Text
Definition: SampleProf.h:92
llvm::sampleprof::SampleProfileReader::computeSummary
void computeSummary()
Compute summary for this profile.
Definition: SampleProfReader.cpp:1968
llvm::sampleprof::HIST_TYPE_INTERVAL
@ HIST_TYPE_INTERVAL
Definition: SampleProfReader.h:850
llvm::sampleprof::SampleProfileReader::getFormat
SampleProfileFormat getFormat() const
Return the profile format.
Definition: SampleProfReader.h:471
llvm::sampleprof::SampleProfileReader::getSummary
ProfileSummary & getSummary() const
Return the profile summary.
Definition: SampleProfReader.h:466
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::sampleprof::SampleProfileReaderRawBinary
Definition: SampleProfReader.h:660
llvm::sampleprof::SampleProfileReader::getProfiles
SampleProfileMap & getProfiles()
Return all the profiles.
Definition: SampleProfReader.h:441
llvm::LLVMContext::diagnose
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
Definition: LLVMContext.cpp:248
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
std
Definition: BitVector.h:851
llvm::sampleprof::SampleProfileReader::Profiles
SampleProfileMap Profiles
Map every function to its associated profile.
Definition: SampleProfReader.h:510
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:408
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:1553
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:1494
llvm::sampleprof::SampleProfileReaderGCC::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1583
llvm::sampleprof::HIST_TYPE_SINGLE_VALUE
@ HIST_TYPE_SINGLE_VALUE
Definition: SampleProfReader.h:852
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncsToUse
DenseSet< StringRef > FuncsToUse
The set containing the functions to use when compiling a module.
Definition: SampleProfReader.h:737
DiagnosticInfo.h
llvm::sampleprof::SecType
SecType
Definition: SampleProf.h:121
llvm::sampleprof::SampleProfileReader
Sample-based profile reader.
Definition: SampleProfReader.h:342
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getFileSize
uint64_t getFileSize()
Get the total size of header and all sections.
Definition: SampleProfReader.cpp:1313
llvm::sampleprof::SampleProfileReaderExtBinaryBase::MD5NameMemStart
const uint8_t * MD5NameMemStart
The starting address of NameTable containing fixed length MD5.
Definition: SampleProfReader.h:743
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1289
llvm::sampleprof::SampleProfileReader::setModule
void setModule(const Module *Mod)
Definition: SampleProfReader.h:502
llvm::sampleprof::HIST_TYPE_INDIR_CALL_TOPN
@ HIST_TYPE_INDIR_CALL_TOPN
Definition: SampleProfReader.h:857
llvm::sampleprof::SampleProfileReader::profileIsPreInlined
bool profileIsPreInlined() const
Whether input profile contains ShouldBeInlined contexts.
Definition: SampleProfReader.h:480
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:501
llvm::sampleprof::SampleProfileReader::dumpJson
void dumpJson(raw_ostream &OS=dbgs())
Print all the profiles on stream OS in the JSON format.
Definition: SampleProfReader.cpp:136
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:1028
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SkipFlatProf
bool SkipFlatProf
If SkipFlatProf is true, skip the sections with SecFlagFlat flag.
Definition: SampleProfReader.h:760
llvm::sampleprof::SampleProfileReaderBinary::readNumber
ErrorOr< T > readNumber()
Read a numeric value of type T from the profile.
Definition: SampleProfReader.cpp:466
llvm::sampleprof::SampleProfileReader::dumpSectionInfo
virtual bool dumpSectionInfo(raw_ostream &OS=dbgs())
Definition: SampleProfReader.h:489
llvm::sampleprof::SampleProfileReaderBinary::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:684
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncProfiles
std::error_code readFuncProfiles()
Definition: SampleProfReader.cpp:829
llvm::sampleprof::SampleProfileReader::Ctx
LLVMContext & Ctx
LLVM context used to emit diagnostics.
Definition: SampleProfReader.h:513
SmallVector.h
llvm::sampleprof::SampleProfileReaderCompactBinary::collectFuncsFromModule
bool collectFuncsFromModule() override
Collect functions with definitions in Module M.
Definition: SampleProfReader.cpp:1467
llvm::sampleprof::SampleProfileReaderBinary
Definition: SampleProfReader.h:584
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:492
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readOneSection
virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size, const SecHdrTableEntry &Entry)
Definition: SampleProfReader.cpp:720
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncOffsetTable
std::error_code readFuncOffsetTable()
Definition: SampleProfReader.cpp:794
llvm::sampleprof::SampleProfileReader::dumpFunctionProfile
void dumpFunctionProfile(SampleContext FContext, raw_ostream &OS=dbgs())
Print the profile for FContext on stream OS.
Definition: SampleProfReader.cpp:63
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readProfileSymbolList
std::error_code readProfileSymbolList()
Definition: SampleProfReader.cpp:929
llvm::sampleprof::SampleProfileReaderItaniumRemapper
SampleProfileReaderItaniumRemapper remaps the profile data from a sample profile data reader,...
Definition: SampleProfReader.h:261
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:1546
llvm::sampleprof::SampleProfileReaderItaniumRemapper::hasApplied
bool hasApplied()
Definition: SampleProfReader.h:285
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:356
llvm::sampleprof::SampleProfileReader::ProfileIsCS
bool ProfileIsCS
Whether function profiles are context-sensitive flat profiles.
Definition: SampleProfReader.h:540
LLVMContext.h
llvm::GCOVBuffer
GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations.
Definition: GCOV.h:72
llvm::sampleprof::SampleProfileReaderExtBinaryBase::dumpSectionInfo
bool dumpSectionInfo(raw_ostream &OS=dbgs()) override
Definition: SampleProfReader.cpp:1376
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::sampleprof::HIST_TYPE_POW2
@ HIST_TYPE_POW2
Definition: SampleProfReader.h:851
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:1539
llvm::sampleprof::SampleProfileReaderExtBinaryBase::OrderedFuncOffsets
std::unique_ptr< std::vector< std::pair< SampleContext, uint64_t > > > OrderedFuncOffsets
Function offset mapping ordered by contexts.
Definition: SampleProfReader.h:734
llvm::sampleprof::SampleProfileReaderGCC::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:1779
llvm::sampleprof::SampleProfileReaderBinary::readStringIndex
ErrorOr< uint32_t > readStringIndex(T &Table)
Read the string index and check whether it overflows the table.
Definition: SampleProfReader.cpp:516
llvm::sampleprof::SampleProfileReaderBinary::Data
const uint8_t * Data
Points to the current location in the buffer.
Definition: SampleProfReader.h:643
Debug.h
llvm::sampleprof::SampleProfileReaderBinary::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1413
llvm::sampleprof::SampleProfileReader::Buffer
std::unique_ptr< MemoryBuffer > Buffer
Memory buffer holding the profile file.
Definition: SampleProfReader.h:516
llvm::sampleprof::SampleProfileReaderCompactBinary::SampleProfileReaderCompactBinary
SampleProfileReaderCompactBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:827
llvm::sampleprof::HistType
HistType
Definition: SampleProfReader.h:849
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:785
llvm::sampleprof::SampleProfileReader::ProfileIsProbeBased
bool ProfileIsProbeBased
Whether samples are collected based on pseudo probes.
Definition: SampleProfReader.h:537
llvm::sampleprof::SampleProfileReaderBinary::at_eof
bool at_eof() const
Return true if we've reached the end of file.
Definition: SampleProfReader.h:625