LLVM  14.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 <list>
246 #include <memory>
247 #include <string>
248 #include <system_error>
249 #include <unordered_set>
250 #include <vector>
251 
252 namespace llvm {
253 
254 class raw_ostream;
255 class Twine;
256 
257 namespace sampleprof {
258 
259 class SampleProfileReader;
260 
261 /// SampleProfileReaderItaniumRemapper remaps the profile data from a
262 /// sample profile data reader, by applying a provided set of equivalences
263 /// between components of the symbol names in the profile.
265 public:
266  SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B,
267  std::unique_ptr<SymbolRemappingReader> SRR,
269  : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
270  assert(Remappings && "Remappings cannot be nullptr");
271  }
272 
273  /// Create a remapper from the given remapping file. The remapper will
274  /// be used for profile read in by Reader.
276  create(const std::string Filename, SampleProfileReader &Reader,
277  LLVMContext &C);
278 
279  /// Create a remapper from the given Buffer. The remapper will
280  /// be used for profile read in by Reader.
282  create(std::unique_ptr<MemoryBuffer> &B, SampleProfileReader &Reader,
283  LLVMContext &C);
284 
285  /// Apply remappings to the profile read by Reader.
286  void applyRemapping(LLVMContext &Ctx);
287 
288  bool hasApplied() { return RemappingApplied; }
289 
290  /// Insert function name into remapper.
291  void insert(StringRef FunctionName) { Remappings->insert(FunctionName); }
292 
293  /// Query whether there is equivalent in the remapper which has been
294  /// inserted.
295  bool exist(StringRef FunctionName) {
296  return Remappings->lookup(FunctionName);
297  }
298 
299  /// Return the equivalent name in the profile for \p FunctionName if
300  /// it exists.
302 
303 private:
304  // The buffer holding the content read from remapping file.
305  std::unique_ptr<MemoryBuffer> Buffer;
306  std::unique_ptr<SymbolRemappingReader> Remappings;
307  // Map remapping key to the name in the profile. By looking up the
308  // key in the remapper, a given new name can be mapped to the
309  // cannonical name using the NameMap.
311  // The Reader the remapper is servicing.
312  SampleProfileReader &Reader;
313  // Indicate whether remapping has been applied to the profile read
314  // by Reader -- by calling applyRemapping.
315  bool RemappingApplied = false;
316 };
317 
318 /// Sample-based profile reader.
319 ///
320 /// Each profile contains sample counts for all the functions
321 /// executed. Inside each function, statements are annotated with the
322 /// collected samples on all the instructions associated with that
323 /// statement.
324 ///
325 /// For this to produce meaningful data, the program needs to be
326 /// compiled with some debug information (at minimum, line numbers:
327 /// -gline-tables-only). Otherwise, it will be impossible to match IR
328 /// instructions to the line numbers collected by the profiler.
329 ///
330 /// From the profile file, we are interested in collecting the
331 /// following information:
332 ///
333 /// * A list of functions included in the profile (mangled names).
334 ///
335 /// * For each function F:
336 /// 1. The total number of samples collected in F.
337 ///
338 /// 2. The samples collected at each line in F. To provide some
339 /// protection against source code shuffling, line numbers should
340 /// be relative to the start of the function.
341 ///
342 /// The reader supports two file formats: text and binary. The text format
343 /// is useful for debugging and testing, while the binary format is more
344 /// compact and I/O efficient. They can both be used interchangeably.
346 public:
347  SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
349  : Profiles(0), Ctx(C), Buffer(std::move(B)), Format(Format) {}
350 
351  virtual ~SampleProfileReader() = default;
352 
353  /// Read and validate the file header.
354  virtual std::error_code readHeader() = 0;
355 
356  /// Set the bits for FS discriminators. Parameter Pass specify the sequence
357  /// number, Pass == i is for the i-th round of adding FS discriminators.
358  /// Pass == 0 is for using base discriminators.
361  }
362 
363  /// Get the bitmask the discriminators: For FS profiles, return the bit
364  /// mask for this pass. For non FS profiles, return (unsigned) -1.
366  if (!ProfileIsFS)
367  return 0xFFFFFFFF;
368  assert((MaskedBitFrom != 0) && "MaskedBitFrom is not set properly");
369  return getN1Bits(MaskedBitFrom);
370  }
371 
372  /// The interface to read sample profiles from the associated file.
373  std::error_code read() {
374  if (std::error_code EC = readImpl())
375  return EC;
376  if (Remapper)
377  Remapper->applyRemapping(Ctx);
380  }
381 
382  /// The implementaion to read sample profiles from the associated file.
383  virtual std::error_code readImpl() = 0;
384 
385  /// Print the profile for \p FContext on stream \p OS.
386  void dumpFunctionProfile(SampleContext FContext, raw_ostream &OS = dbgs());
387 
388  /// Collect functions with definitions in Module M. For reader which
389  /// support loading function profiles on demand, return true when the
390  /// reader has been given a module. Always return false for reader
391  /// which doesn't support loading function profiles on demand.
392  virtual bool collectFuncsFromModule() { return false; }
393 
394  /// Print all the profiles on stream \p OS.
395  void dump(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  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
480  return nullptr;
481  };
482 
483  /// It includes all the names that have samples either in outline instance
484  /// or inline instance.
485  virtual std::vector<StringRef> *getNameTable() { return nullptr; }
486  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
487 
488  /// Return whether names in the profile are all MD5 numbers.
489  virtual bool useMD5() { return false; }
490 
491  /// Don't read profile without context if the flag is set. This is only meaningful
492  /// for ExtBinary format.
493  virtual void setSkipFlatProf(bool Skip) {}
494  /// Return whether any name in the profile contains ".__uniq." suffix.
495  virtual bool hasUniqSuffix() { return false; }
496 
498 
499  void setModule(const Module *Mod) { M = Mod; }
500 
501 protected:
502  /// Map every function to its associated profile.
503  ///
504  /// The profile of every function executed at runtime is collected
505  /// in the structure FunctionSamples. This maps function objects
506  /// to their corresponding profiles.
508 
509  /// LLVM context used to emit diagnostics.
511 
512  /// Memory buffer holding the profile file.
513  std::unique_ptr<MemoryBuffer> Buffer;
514 
515  /// Extra name buffer holding names created on demand.
516  /// This should only be needed for md5 profiles.
517  std::unordered_set<std::string> MD5NameBuffer;
518 
519  /// Profile summary information.
520  std::unique_ptr<ProfileSummary> Summary;
521 
522  /// Take ownership of the summary of this reader.
523  static std::unique_ptr<ProfileSummary>
525  return std::move(Reader.Summary);
526  }
527 
528  /// Compute summary for this profile.
529  void computeSummary();
530 
531  std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper;
532 
533  /// \brief Whether samples are collected based on pseudo probes.
534  bool ProfileIsProbeBased = false;
535 
536  /// Whether function profiles are context-sensitive.
537  bool ProfileIsCS = false;
538 
539  /// Number of context-sensitive profiles.
541 
542  /// Whether the function profiles use FS discriminators.
543  bool ProfileIsFS = false;
544 
545  /// \brief The format of sample.
547 
548  /// \brief The current module being compiled if SampleProfileReader
549  /// is used by compiler. If SampleProfileReader is used by other
550  /// tools which are not compiler, M is usually nullptr.
551  const Module *M = nullptr;
552 
553  /// Zero out the discriminator bits higher than bit MaskedBitFrom (0 based).
554  /// The default is to keep all the bits.
556 };
557 
559 public:
560  SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
562 
563  /// Read and validate the file header.
564  std::error_code readHeader() override { return sampleprof_error::success; }
565 
566  /// Read sample profiles from the associated file.
567  std::error_code readImpl() override;
568 
569  /// Return true if \p Buffer is in the format supported by this class.
570  static bool hasFormat(const MemoryBuffer &Buffer);
571 
572 private:
573  /// CSNameTable is used to save full context vectors. This serves as an
574  /// underlying immutable buffer for all clients.
575  std::list<SampleContextFrameVector> CSNameTable;
576 };
577 
579 public:
580  SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
583 
584  /// Read and validate the file header.
585  virtual std::error_code readHeader() override;
586 
587  /// Read sample profiles from the associated file.
588  std::error_code readImpl() override;
589 
590  /// It includes all the names that have samples either in outline instance
591  /// or inline instance.
592  virtual std::vector<StringRef> *getNameTable() override { return &NameTable; }
593 
594 protected:
595  /// Read a numeric value of type T from the profile.
596  ///
597  /// If an error occurs during decoding, a diagnostic message is emitted and
598  /// EC is set.
599  ///
600  /// \returns the read value.
601  template <typename T> ErrorOr<T> readNumber();
602 
603  /// Read a numeric value of type T from the profile. The value is saved
604  /// without encoded.
605  template <typename T> ErrorOr<T> readUnencodedNumber();
606 
607  /// Read a string from the profile.
608  ///
609  /// If an error occurs during decoding, a diagnostic message is emitted and
610  /// EC is set.
611  ///
612  /// \returns the read value.
614 
615  /// Read the string index and check whether it overflows the table.
616  template <typename T> inline ErrorOr<uint32_t> readStringIndex(T &Table);
617 
618  /// Return true if we've reached the end of file.
619  bool at_eof() const { return Data >= End; }
620 
621  /// Read the next function profile instance.
622  std::error_code readFuncProfile(const uint8_t *Start);
623 
624  /// Read the contents of the given profile instance.
625  std::error_code readProfile(FunctionSamples &FProfile);
626 
627  /// Read the contents of Magic number and Version number.
628  std::error_code readMagicIdent();
629 
630  /// Read profile summary.
631  std::error_code readSummary();
632 
633  /// Read the whole name table.
634  virtual std::error_code readNameTable();
635 
636  /// Points to the current location in the buffer.
637  const uint8_t *Data = nullptr;
638 
639  /// Points to the end of the buffer.
640  const uint8_t *End = nullptr;
641 
642  /// Function name table.
643  std::vector<StringRef> NameTable;
644 
645  /// Read a string indirectly via the name table.
648 
649 private:
650  std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
651  virtual std::error_code verifySPMagic(uint64_t Magic) = 0;
652 };
653 
655 private:
656  virtual std::error_code verifySPMagic(uint64_t Magic) override;
657 
658 public:
659  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
662 
663  /// \brief Return true if \p Buffer is in the format supported by this class.
664  static bool hasFormat(const MemoryBuffer &Buffer);
665 };
666 
667 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines
668 /// the basic structure of the extensible binary format.
669 /// The format is organized in sections except the magic and version number
670 /// at the beginning. There is a section table before all the sections, and
671 /// each entry in the table describes the entry type, start, size and
672 /// attributes. The format in each section is defined by the section itself.
673 ///
674 /// It is easy to add a new section while maintaining the backward
675 /// compatibility of the profile. Nothing extra needs to be done. If we want
676 /// to extend an existing section, like add cache misses information in
677 /// addition to the sample count in the profile body, we can add a new section
678 /// with the extension and retire the existing section, and we could choose
679 /// to keep the parser of the old section if we want the reader to be able
680 /// to read both new and old format profile.
681 ///
682 /// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the
683 /// commonly used sections of a profile in extensible binary format. It is
684 /// possible to define other types of profile inherited from
685 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase.
687 private:
688  std::error_code decompressSection(const uint8_t *SecStart,
689  const uint64_t SecSize,
690  const uint8_t *&DecompressBuf,
691  uint64_t &DecompressBufSize);
692 
693  BumpPtrAllocator Allocator;
694 
695 protected:
696  std::vector<SecHdrTableEntry> SecHdrTable;
697  std::error_code readSecHdrTableEntry(uint32_t Idx);
698  std::error_code readSecHdrTable();
699 
700  std::error_code readFuncMetadata(bool ProfileHasAttribute);
701  std::error_code readFuncOffsetTable();
702  std::error_code readFuncProfiles();
703  std::error_code readMD5NameTable();
704  std::error_code readNameTableSec(bool IsMD5);
705  std::error_code readCSNameTableSec();
706  std::error_code readProfileSymbolList();
707 
708  virtual std::error_code readHeader() override;
709  virtual std::error_code verifySPMagic(uint64_t Magic) override = 0;
710  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
711  const SecHdrTableEntry &Entry);
712  // placeholder for subclasses to dispatch their own section readers.
713  virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry) = 0;
714  virtual ErrorOr<StringRef> readStringFromTable() override;
717 
718  std::unique_ptr<ProfileSymbolList> ProfSymList;
719 
720  /// The table mapping from function context to the offset of its
721  /// FunctionSample towards file start.
723 
724  /// Function offset mapping ordered by contexts.
725  std::unique_ptr<std::vector<std::pair<SampleContext, uint64_t>>>
727 
728  /// The set containing the functions to use when compiling a module.
730 
731  /// Use fixed length MD5 instead of ULEB128 encoding so NameTable doesn't
732  /// need to be read in up front and can be directly accessed using index.
733  bool FixedLengthMD5 = false;
734  /// The starting address of NameTable containing fixed length MD5.
735  const uint8_t *MD5NameMemStart = nullptr;
736 
737  /// If MD5 is used in NameTable section, the section saves uint64_t data.
738  /// The uint64_t data has to be converted to a string and then the string
739  /// will be used to initialize StringRef in NameTable.
740  /// Note NameTable contains StringRef so it needs another buffer to own
741  /// the string data. MD5StringBuf serves as the string buffer that is
742  /// referenced by NameTable (vector of StringRef). We make sure
743  /// the lifetime of MD5StringBuf is not shorter than that of NameTable.
744  std::unique_ptr<std::vector<std::string>> MD5StringBuf;
745 
746  /// CSNameTable is used to save full context vectors. This serves as an
747  /// underlying immutable buffer for all clients.
748  std::unique_ptr<const std::vector<SampleContextFrameVector>> CSNameTable;
749 
750  /// If SkipFlatProf is true, skip the sections with
751  /// SecFlagFlat flag.
752  bool SkipFlatProf = false;
753 
754  bool FuncOffsetsOrdered = false;
755 
756 public:
757  SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B,
760 
761  /// Read sample profiles in extensible format from the associated file.
762  std::error_code readImpl() override;
763 
764  /// Get the total size of all \p Type sections.
766  /// Get the total size of header and all sections.
768  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) override;
769 
770  /// Collect functions with definitions in Module M. Return true if
771  /// the reader has been given a module.
772  bool collectFuncsFromModule() override;
773 
774  /// Return whether names in the profile are all MD5 numbers.
775  virtual bool useMD5() override { return MD5StringBuf.get(); }
776 
777  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
778  return std::move(ProfSymList);
779  };
780 
781  virtual void setSkipFlatProf(bool Skip) override { SkipFlatProf = Skip; }
782 };
783 
785 private:
786  virtual std::error_code verifySPMagic(uint64_t Magic) override;
787  virtual std::error_code
788  readCustomSection(const SecHdrTableEntry &Entry) override {
789  // Update the data reader pointer to the end of the section.
790  Data = End;
792  };
793 
794 public:
795  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
798 
799  /// \brief Return true if \p Buffer is in the format supported by this class.
800  static bool hasFormat(const MemoryBuffer &Buffer);
801 };
802 
804 private:
805  /// Function name table.
806  std::vector<std::string> NameTable;
807  /// The table mapping from function name to the offset of its FunctionSample
808  /// towards file start.
809  DenseMap<StringRef, uint64_t> FuncOffsetTable;
810  /// The set containing the functions to use when compiling a module.
811  DenseSet<StringRef> FuncsToUse;
812  virtual std::error_code verifySPMagic(uint64_t Magic) override;
813  virtual std::error_code readNameTable() override;
814  /// Read a string indirectly via the name table.
815  virtual ErrorOr<StringRef> readStringFromTable() override;
816  virtual std::error_code readHeader() override;
817  std::error_code readFuncOffsetTable();
818 
819 public:
820  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
821  LLVMContext &C)
823 
824  /// \brief Return true if \p Buffer is in the format supported by this class.
825  static bool hasFormat(const MemoryBuffer &Buffer);
826 
827  /// Read samples only for functions to use.
828  std::error_code readImpl() override;
829 
830  /// Collect functions with definitions in Module M. Return true if
831  /// the reader has been given a module.
832  bool collectFuncsFromModule() override;
833 
834  /// Return whether names in the profile are all MD5 numbers.
835  virtual bool useMD5() override { return true; }
836 };
837 
839 
840 // Supported histogram types in GCC. Currently, we only need support for
841 // call target histograms.
842 enum HistType {
851 };
852 
854 public:
855  SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
857  GcovBuffer(Buffer.get()) {}
858 
859  /// Read and validate the file header.
860  std::error_code readHeader() override;
861 
862  /// Read sample profiles from the associated file.
863  std::error_code readImpl() override;
864 
865  /// Return true if \p Buffer is in the format supported by this class.
866  static bool hasFormat(const MemoryBuffer &Buffer);
867 
868 protected:
869  std::error_code readNameTable();
870  std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack,
871  bool Update, uint32_t Offset);
872  std::error_code readFunctionProfiles();
873  std::error_code skipNextWord();
874  template <typename T> ErrorOr<T> readNumber();
876 
877  /// Read the section tag and check that it's the same as \p Expected.
878  std::error_code readSectionTag(uint32_t Expected);
879 
880  /// GCOV buffer containing the profile.
882 
883  /// Function names in this profile.
884  std::vector<std::string> Names;
885 
886  /// GCOV tags used to separate sections in the profile file.
887  static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
888  static const uint32_t GCOVTagAFDOFunction = 0xac000000;
889 };
890 
891 } // end namespace sampleprof
892 
893 } // end namespace llvm
894 
895 #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:543
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:558
llvm::sampleprof::SampleProfileReaderBinary::readNameTable
virtual std::error_code readNameTable()
Read the whole name table.
Definition: SampleProfReader.cpp:987
llvm::sampleprof::SampleProfileReader::CSProfileCount
uint32_t CSProfileCount
Number of context-sensitive profiles.
Definition: SampleProfReader.h:540
llvm::sampleprof::SampleProfileReaderText::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:242
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:733
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:1751
llvm::sampleprof::SampleProfileReaderExtBinary::SampleProfileReaderExtBinary
SampleProfileReaderExtBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Ext_Binary)
Definition: SampleProfReader.h:795
llvm
This is an optimization pass for GlobalISel generic memory operations.
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:551
llvm::sampleprof::SampleProfileReader::Remapper
std::unique_ptr< SampleProfileReaderItaniumRemapper > Remapper
Definition: SampleProfReader.h:531
Optional.h
llvm::sampleprof::SampleProfileReaderExtBinaryBase::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:775
llvm::sampleprof::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines the basic structure of the ...
Definition: SampleProfReader.h:686
llvm::sampleprof::SampleProfileReaderBinary::SampleProfileReaderBinary
SampleProfileReaderBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Definition: SampleProfReader.h:580
llvm::sampleprof::SampleProfileReaderGCC::readFunctionProfiles
std::error_code readFunctionProfiles()
Definition: SampleProfReader.cpp:1508
llvm::sampleprof::SampleProfileReader::profileIsProbeBased
bool profileIsProbeBased() const
Whether input profile is based on pseudo probes.
Definition: SampleProfReader.h:474
llvm::Function
Definition: Function.h:62
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:1476
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:659
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readCSNameTableSec
std::error_code readCSNameTableSec()
Definition: SampleProfReader.cpp:1042
llvm::sampleprof::SampleProfileReaderBinary::readProfile
std::error_code readProfile(FunctionSamples &FProfile)
Read the contents of the given profile instance.
Definition: SampleProfReader.cpp:499
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readContextFromTable
ErrorOr< SampleContextFrames > readContextFromTable()
Definition: SampleProfReader.cpp:617
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SampleProfileReaderExtBinaryBase
SampleProfileReaderExtBinaryBase(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format)
Definition: SampleProfReader.h:757
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SecHdrTable
std::vector< SecHdrTableEntry > SecHdrTable
Definition: SampleProfReader.h:696
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable() override
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:462
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:1664
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readNameTableSec
std::error_code readNameTableSec(bool IsMD5)
Definition: SampleProfReader.cpp:1032
llvm::sampleprof::SampleProfileReaderGCC::GcovBuffer
GCOVBuffer GcovBuffer
GCOV buffer containing the profile.
Definition: SampleProfReader.h:881
llvm::sampleprof::SampleProfileMap
std::unordered_map< SampleContext, FunctionSamples, SampleContext::Hash > SampleProfileMap
Definition: SampleProf.h:1109
llvm::sampleprof::SampleProfileReaderItaniumRemapper::applyRemapping
void applyRemapping(LLVMContext &Ctx)
Apply remappings to the profile read by Reader.
Definition: SampleProfReader.cpp:1669
Discriminator.h
llvm::sampleprof::SPF_GCC
@ SPF_GCC
Definition: SampleProf.h:94
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: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:748
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readCustomSection
virtual std::error_code readCustomSection(const SecHdrTableEntry &Entry)=0
llvm::sampleprof::SampleProfileReaderGCC::readNameTable
std::error_code readNameTable()
Definition: SampleProfReader.cpp:1490
llvm::sampleprof::SampleProfileReaderGCC::Names
std::vector< std::string > Names
Function names in this profile.
Definition: SampleProfReader.h:884
llvm::sampleprof::SampleProfileReaderText::SampleProfileReaderText
SampleProfileReaderText(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:560
llvm::Optional
Definition: APInt.h:33
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readMD5NameTable
std::error_code readMD5NameTable()
Definition: SampleProfReader.cpp:1002
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncOffsetsOrdered
bool FuncOffsetsOrdered
Definition: SampleProfReader.h:754
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTableEntry
std::error_code readSecHdrTableEntry(uint32_t Idx)
Definition: SampleProfReader.cpp:1124
llvm::sampleprof::HIST_TYPE_IOR
@ HIST_TYPE_IOR
Definition: SampleProfReader.h:849
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSampleContextFromTable
virtual ErrorOr< SampleContext > readSampleContextFromTable() override
Definition: SampleProfReader.cpp:627
llvm::sampleprof::SampleProfileReader::collectFuncsFromModule
virtual bool collectFuncsFromModule()
Collect functions with definitions in Module M.
Definition: SampleProfReader.h:392
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
llvm::sampleprof::SampleProfileReader::getRemapper
SampleProfileReaderItaniumRemapper * getRemapper()
Definition: SampleProfReader.h:497
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:520
llvm::sampleprof::SampleProfileReaderGCC::readOneFunctionProfile
std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack, bool Update, uint32_t Offset)
Definition: SampleProfReader.cpp:1525
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:96
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::sampleprof::SampleProfileReaderGCC::readNumber
ErrorOr< T > readNumber()
Definition: SampleProfReader.cpp:1432
llvm::sampleprof::SampleProfileReaderBinary::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable()
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:447
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:847
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:365
llvm::sampleprof::SampleProfileReaderBinary::NameTable
std::vector< StringRef > NameTable
Function name table.
Definition: SampleProfReader.h:643
llvm::sampleprof::SampleProfileReader::takeSummary
static std::unique_ptr< ProfileSummary > takeSummary(SampleProfileReader &Reader)
Take ownership of the summary of this reader.
Definition: SampleProfReader.h:524
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:934
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:1404
llvm::sampleprof::SampleProfileReader::read
std::error_code read()
The interface to read sample profiles from the associated file.
Definition: SampleProfReader.h:373
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:582
llvm::sampleprof::SampleProfileReader::MD5NameBuffer
std::unordered_set< std::string > MD5NameBuffer
Extra name buffer holding names created on demand.
Definition: SampleProfReader.h:517
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:1696
llvm::sampleprof::SampleProfileReaderBinary::readString
ErrorOr< StringRef > readString()
Read a string from the profile.
Definition: SampleProfReader.cpp:408
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList() override
Definition: SampleProfReader.h:777
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:722
llvm::sampleprof::SampleProfileReader::getBuffer
MemoryBuffer * getBuffer() const
Definition: SampleProfReader.h:468
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:371
llvm::sampleprof::SampleProfileReaderExtBinaryBase::setSkipFlatProf
virtual void setSkipFlatProf(bool Skip) override
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:781
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:485
llvm::sampleprof::SampleContext
Definition: SampleProf.h:469
llvm::sampleprof::HIST_TYPE_CONST_DELTA
@ HIST_TYPE_CONST_DELTA
Definition: SampleProfReader.h:846
llvm::sampleprof::SampleProfileReaderItaniumRemapper::exist
bool exist(StringRef FunctionName)
Query whether there is equivalent in the remapper which has been inserted.
Definition: SampleProfReader.h:295
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:1151
uint64_t
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getSectionSize
uint64_t getSectionSize(SecType Type)
Get the total size of all Type sections.
Definition: SampleProfReader.cpp:1178
llvm::sampleprof::SampleProfileReader::getSamplesFor
FunctionSamples * getSamplesFor(const Function &F)
Return the samples collected for function F.
Definition: SampleProfReader.h:398
llvm::sampleprof::SampleProfileReaderItaniumRemapper::insert
void insert(StringRef FunctionName)
Insert function name into remapper.
Definition: SampleProfReader.h:291
llvm::sampleprof::SampleProfileReaderGCC
Definition: SampleProfReader.h:853
llvm::sampleprof::FunctionSamples
Representation of the samples collected for a function.
Definition: SampleProf.h:688
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:718
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFileNames
static const uint32_t GCOVTagAFDOFileNames
GCOV tags used to separate sections in the profile file.
Definition: SampleProfReader.h:887
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:744
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:347
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:855
llvm::DenseMap
Definition: DenseMap.h:714
ErrorOr.h
llvm::sampleprof::SampleProfileReader::Format
SampleProfileFormat Format
The format of sample.
Definition: SampleProfReader.h:546
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:266
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:555
llvm::ProfileSummary
Definition: ProfileSummary.h:45
llvm::sampleprof::SampleProfileReaderBinary::readSampleContextFromTable
virtual ErrorOr< SampleContext > readSampleContextFromTable()
Definition: SampleProfReader.cpp:455
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:1658
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncMetadata
std::error_code readFuncMetadata(bool ProfileHasAttribute)
Definition: SampleProfReader.cpp:1081
llvm::sampleprof::HIST_TYPE_AVERAGE
@ HIST_TYPE_AVERAGE
Definition: SampleProfReader.h:848
llvm::sampleprof::FunctionSamples::UseMD5
static bool UseMD5
Whether the profile uses MD5 to represent string.
Definition: SampleProf.h:1039
llvm::sampleprof::SampleProfileReaderGCC::readString
ErrorOr< StringRef > readString()
Definition: SampleProfReader.cpp:1448
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:1731
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:493
llvm::DiagnosticInfoSampleProfile
Diagnostic information for the sample profiler.
Definition: DiagnosticInfo.h:286
llvm::sampleprof::SampleProfileReaderExtBinary
Definition: SampleProfReader.h:784
llvm::sampleprof::SampleProfileReaderBinary::readMagicIdent
std::error_code readMagicIdent()
Read the contents of Magic number and Version number.
Definition: SampleProfReader.cpp:1267
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFunction
static const uint32_t GCOVTagAFDOFunction
Definition: SampleProfReader.h:888
llvm::sampleprof::SampleProfileReaderBinary::End
const uint8_t * End
Points to the end of the buffer.
Definition: SampleProfReader.h:640
llvm::sampleprof::SampleProfileReaderCompactBinary
Definition: SampleProfReader.h:803
llvm::sampleprof::SampleProfileReader::hasUniqSuffix
virtual bool hasUniqSuffix()
Return whether any name in the profile contains ".__uniq." suffix.
Definition: SampleProfReader.h:495
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readImpl
std::error_code readImpl() override
Read sample profiles in extensible format from the associated file.
Definition: SampleProfReader.cpp:888
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
llvm::sampleprof::SampleProfileReader::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList()
Definition: SampleProfReader.h:479
uint32_t
llvm::sampleprof::SampleProfileReaderText::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.h:564
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:1841
llvm::sampleprof::HIST_TYPE_INTERVAL
@ HIST_TYPE_INTERVAL
Definition: SampleProfReader.h:843
llvm::sampleprof::SampleProfileReader::getFormat
SampleProfileFormat getFormat() const
Return the profile format.
Definition: SampleProfReader.h:471
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:592
llvm::sampleprof::SampleProfileReader::getSummary
ProfileSummary & getSummary() const
Return the profile summary.
Definition: SampleProfReader.h:466
llvm::sampleprof::SampleProfileReaderRawBinary
Definition: SampleProfReader.h:654
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:228
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
std
Definition: BitVector.h:838
llvm::sampleprof::SampleProfileReader::Profiles
SampleProfileMap Profiles
Map every function to its associated profile.
Definition: SampleProfReader.h:507
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:1425
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:1366
llvm::sampleprof::SampleProfileReaderGCC::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1455
llvm::sampleprof::SampleProfileReaderCompactBinary::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:835
llvm::sampleprof::HIST_TYPE_SINGLE_VALUE
@ HIST_TYPE_SINGLE_VALUE
Definition: SampleProfReader.h:845
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncsToUse
DenseSet< StringRef > FuncsToUse
The set containing the functions to use when compiling a module.
Definition: SampleProfReader.h:729
DiagnosticInfo.h
Function.h
llvm::sampleprof::SecType
SecType
Definition: SampleProf.h:121
llvm::sampleprof::SampleProfileReader
Sample-based profile reader.
Definition: SampleProfReader.h:345
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getFileSize
uint64_t getFileSize()
Get the total size of header and all sections.
Definition: SampleProfReader.cpp:1187
llvm::sampleprof::SampleProfileReaderExtBinaryBase::MD5NameMemStart
const uint8_t * MD5NameMemStart
The starting address of NameTable containing fixed length MD5.
Definition: SampleProfReader.h:735
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readHeader
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1163
llvm::sampleprof::SampleProfileReader::setModule
void setModule(const Module *Mod)
Definition: SampleProfReader.h:499
llvm::sampleprof::HIST_TYPE_INDIR_CALL_TOPN
@ HIST_TYPE_INDIR_CALL_TOPN
Definition: SampleProfReader.h:850
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:422
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:944
llvm::sampleprof::SampleProfileReaderExtBinaryBase::SkipFlatProf
bool SkipFlatProf
If SkipFlatProf is true, skip the sections with SecFlagFlat flag.
Definition: SampleProfReader.h:752
llvm::sampleprof::SampleProfileReaderBinary::readNumber
ErrorOr< T > readNumber()
Read a numeric value of type T from the profile.
Definition: SampleProfReader.cpp:387
llvm::sampleprof::SampleProfileReader::dumpSectionInfo
virtual bool dumpSectionInfo(raw_ostream &OS=dbgs())
Definition: SampleProfReader.h:486
llvm::sampleprof::SampleProfileReaderBinary::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:605
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncProfiles
std::error_code readFuncProfiles()
Definition: SampleProfReader.cpp:748
llvm::sampleprof::SampleProfileReader::Ctx
LLVMContext & Ctx
LLVM context used to emit diagnostics.
Definition: SampleProfReader.h:510
SmallVector.h
llvm::sampleprof::SampleProfileReaderCompactBinary::collectFuncsFromModule
bool collectFuncsFromModule() override
Collect functions with definitions in Module M.
Definition: SampleProfReader.cpp:1339
llvm::sampleprof::SampleProfileReaderBinary
Definition: SampleProfReader.h:578
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:489
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readOneSection
virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size, const SecHdrTableEntry &Entry)
Definition: SampleProfReader.cpp:641
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncOffsetTable
std::error_code readFuncOffsetTable()
Definition: SampleProfReader.cpp:713
llvm::sampleprof::SampleProfileReader::dumpFunctionProfile
void dumpFunctionProfile(SampleContext FContext, raw_ostream &OS=dbgs())
Print the profile for FContext on stream OS.
Definition: SampleProfReader.cpp:62
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readProfileSymbolList
std::error_code readProfileSymbolList()
Definition: SampleProfReader.cpp:848
llvm::sampleprof::SampleProfileReaderItaniumRemapper
SampleProfileReaderItaniumRemapper remaps the profile data from a sample profile data reader,...
Definition: SampleProfReader.h:264
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:1418
llvm::sampleprof::SampleProfileReaderItaniumRemapper::hasApplied
bool hasApplied()
Definition: SampleProfReader.h:288
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:359
llvm::sampleprof::SampleProfileReader::ProfileIsCS
bool ProfileIsCS
Whether function profiles are context-sensitive.
Definition: SampleProfReader.h:537
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:1248
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::sampleprof::HIST_TYPE_POW2
@ HIST_TYPE_POW2
Definition: SampleProfReader.h:844
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:1411
llvm::sampleprof::SampleProfileReaderExtBinaryBase::OrderedFuncOffsets
std::unique_ptr< std::vector< std::pair< SampleContext, uint64_t > > > OrderedFuncOffsets
Function offset mapping ordered by contexts.
Definition: SampleProfReader.h:726
llvm::sampleprof::SampleProfileReaderGCC::readImpl
std::error_code readImpl() override
Read sample profiles from the associated file.
Definition: SampleProfReader.cpp:1651
llvm::sampleprof::SampleProfileReaderBinary::readStringIndex
ErrorOr< uint32_t > readStringIndex(T &Table)
Read the string index and check whether it overflows the table.
Definition: SampleProfReader.cpp:437
llvm::sampleprof::SampleProfileReaderBinary::Data
const uint8_t * Data
Points to the current location in the buffer.
Definition: SampleProfReader.h:637
Debug.h
llvm::sampleprof::SampleProfileReaderBinary::readHeader
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1285
llvm::sampleprof::SampleProfileReader::Buffer
std::unique_ptr< MemoryBuffer > Buffer
Memory buffer holding the profile file.
Definition: SampleProfReader.h:513
llvm::sampleprof::SampleProfileReaderCompactBinary::SampleProfileReaderCompactBinary
SampleProfileReaderCompactBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
Definition: SampleProfReader.h:820
llvm::sampleprof::HistType
HistType
Definition: SampleProfReader.h:842
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:704
llvm::sampleprof::SampleProfileReader::ProfileIsProbeBased
bool ProfileIsProbeBased
Whether samples are collected based on pseudo probes.
Definition: SampleProfReader.h:534
llvm::sampleprof::SampleProfileReaderBinary::at_eof
bool at_eof() const
Return true if we've reached the end of file.
Definition: SampleProfReader.h:619