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 and flat.
477  bool profileIsCSFlat() const { return ProfileIsCSFlat; }
478 
479  /// Whether input profile is fully context-sensitive and nested.
480  bool profileIsCSNested() const { return ProfileIsCSNested; }
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 ProfileIsCSFlat = false;
541 
542  /// Whether function profiles are context-sensitive nested profiles.
543  bool ProfileIsCSNested = 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  virtual 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  virtual 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  virtual 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  virtual std::error_code readHeader() override;
717  virtual 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;
722  virtual ErrorOr<StringRef> readStringFromTable() override;
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  virtual 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  virtual bool useMD5() override { return MD5StringBuf.get(); }
784 
785  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
786  return std::move(ProfSymList);
787  };
788 
789  virtual void setSkipFlatProf(bool Skip) override { SkipFlatProf = Skip; }
790 };
791 
793 private:
794  virtual std::error_code verifySPMagic(uint64_t Magic) override;
795  virtual std::error_code
796  readCustomSection(const SecHdrTableEntry &Entry) override {
797  // Update the data reader pointer to the end of the section.
798  Data = End;
800  };
801 
802 public:
803  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
806 
807  /// \brief Return true if \p Buffer is in the format supported by this class.
808  static bool hasFormat(const MemoryBuffer &Buffer);
809 };
810 
812 private:
813  /// Function name table.
814  std::vector<std::string> NameTable;
815  /// The table mapping from function name to the offset of its FunctionSample
816  /// towards file start.
817  DenseMap<StringRef, uint64_t> FuncOffsetTable;
818  /// The set containing the functions to use when compiling a module.
819  DenseSet<StringRef> FuncsToUse;
820  virtual std::error_code verifySPMagic(uint64_t Magic) override;
821  virtual std::error_code readNameTable() override;
822  /// Read a string indirectly via the name table.
823  virtual ErrorOr<StringRef> readStringFromTable() override;
824  virtual std::error_code readHeader() override;
825  std::error_code readFuncOffsetTable();
826 
827 public:
828  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
829  LLVMContext &C)
831 
832  /// \brief Return true if \p Buffer is in the format supported by this class.
833  static bool hasFormat(const MemoryBuffer &Buffer);
834 
835  /// Read samples only for functions to use.
836  std::error_code readImpl() override;
837 
838  /// Collect functions with definitions in Module M. Return true if
839  /// the reader has been given a module.
840  bool collectFuncsFromModule() override;
841 
842  /// Return whether names in the profile are all MD5 numbers.
843  virtual bool useMD5() override { return true; }
844 };
845 
847 
848 // Supported histogram types in GCC. Currently, we only need support for
849 // call target histograms.
850 enum HistType {
859 };
860 
862 public:
863  SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
865  GcovBuffer(Buffer.get()) {}
866 
867  /// Read and validate the file header.
868  std::error_code readHeader() override;
869 
870  /// Read sample profiles from the associated file.
871  std::error_code readImpl() override;
872 
873  /// Return true if \p Buffer is in the format supported by this class.
874  static bool hasFormat(const MemoryBuffer &Buffer);
875 
876 protected:
877  std::error_code readNameTable();
878  std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack,
879  bool Update, uint32_t Offset);
880  std::error_code readFunctionProfiles();
881  std::error_code skipNextWord();
882  template <typename T> ErrorOr<T> readNumber();
884 
885  /// Read the section tag and check that it's the same as \p Expected.
886  std::error_code readSectionTag(uint32_t Expected);
887 
888  /// GCOV buffer containing the profile.
890 
891  /// Function names in this profile.
892  std::vector<std::string> Names;
893 
894  /// GCOV tags used to separate sections in the profile file.
895  static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
896  static const uint32_t GCOVTagAFDOFunction = 0xac000000;
897 };
898 
899 } // end namespace sampleprof
900 
901 } // end namespace llvm
902 
903 #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:549
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:564
llvm::sampleprof::SampleProfileReaderBinary::readNameTable
virtual std::error_code readNameTable()
Read the whole name table.
Definition: SampleProfReader.cpp:994
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: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: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:1807
llvm::sampleprof::SampleProfileReaderExtBinary::SampleProfileReaderExtBinary
SampleProfileReaderExtBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Ext_Binary)
Definition: SampleProfReader.h:803
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:557
llvm::sampleprof::SampleProfileReader::Remapper
std::unique_ptr< SampleProfileReaderItaniumRemapper > Remapper
Definition: SampleProfReader.h:534
Optional.h
llvm::sampleprof::SampleProfileReaderExtBinaryBase::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:783
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:1564
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:1532
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:1049
llvm::sampleprof::SampleProfileReaderBinary::readProfile
std::error_code readProfile(FunctionSamples &FProfile)
Read the contents of the given profile instance.
Definition: SampleProfReader.cpp:504
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1177
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readContextFromTable
ErrorOr< SampleContextFrames > readContextFromTable()
Definition: SampleProfReader.cpp:622
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
virtual ErrorOr< StringRef > readStringFromTable() override
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:467
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:1720
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readNameTableSec
std::error_code readNameTableSec(bool IsMD5)
Definition: SampleProfReader.cpp:1039
llvm::sampleprof::SampleProfileReaderGCC::GcovBuffer
GCOVBuffer GcovBuffer
GCOV buffer containing the profile.
Definition: SampleProfReader.h:889
llvm::sampleprof::SampleProfileMap
std::unordered_map< SampleContext, FunctionSamples, SampleContext::Hash > SampleProfileMap
Definition: SampleProf.h:1130
llvm::sampleprof::SampleProfileReaderItaniumRemapper::applyRemapping
void applyRemapping(LLVMContext &Ctx)
Apply remappings to the profile read by Reader.
Definition: SampleProfReader.cpp:1725
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: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:1546
llvm::sampleprof::SampleProfileReaderGCC::Names
std::vector< std::string > Names
Function names in this profile.
Definition: SampleProfReader.h:892
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:1009
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncOffsetsOrdered
bool FuncOffsetsOrdered
Definition: SampleProfReader.h:762
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:80
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSecHdrTableEntry
std::error_code readSecHdrTableEntry(uint32_t Idx)
Definition: SampleProfReader.cpp:1178
llvm::sampleprof::HIST_TYPE_IOR
@ HIST_TYPE_IOR
Definition: SampleProfReader.h:857
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readSampleContextFromTable
virtual ErrorOr< SampleContext > readSampleContextFromTable() override
Definition: SampleProfReader.cpp:632
llvm::sampleprof::SampleProfileReader::collectFuncsFromModule
virtual bool collectFuncsFromModule()
Collect functions with definitions in Module M.
Definition: SampleProfReader.h:392
llvm::sampleprof::SampleProfileReader::ProfileIsCSNested
bool ProfileIsCSNested
Whether function profiles are context-sensitive nested profiles.
Definition: SampleProfReader.h:543
llvm::Expected
Tagged union holding either a T or a Error.
Definition: APFloat.h:42
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:1581
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:55
llvm::sampleprof::SampleProfileReaderGCC::readNumber
ErrorOr< T > readNumber()
Definition: SampleProfReader.cpp:1488
llvm::sampleprof::SampleProfileReaderBinary::readStringFromTable
virtual ErrorOr< StringRef > readStringFromTable()
Read a string indirectly via the name table.
Definition: SampleProfReader.cpp:452
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:855
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: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::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:941
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:1460
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:587
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:1752
llvm::sampleprof::SampleProfileReaderBinary::readString
ErrorOr< StringRef > readString()
Read a string from the profile.
Definition: SampleProfReader.cpp:413
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getProfileSymbolList
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList() override
Definition: SampleProfReader.h:785
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
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:376
llvm::sampleprof::SampleProfileReaderExtBinaryBase::setSkipFlatProf
virtual void setSkipFlatProf(bool Skip) override
Don't read profile without context if the flag is set.
Definition: SampleProfReader.h:789
llvm::sampleprof::SampleProfileReader::profileIsCSNested
bool profileIsCSNested() const
Whether input profile is fully context-sensitive and nested.
Definition: SampleProfReader.h:480
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:472
llvm::sampleprof::HIST_TYPE_CONST_DELTA
@ HIST_TYPE_CONST_DELTA
Definition: SampleProfReader.h:854
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:1205
uint64_t
llvm::sampleprof::SampleProfileReaderExtBinaryBase::getSectionSize
uint64_t getSectionSize(SecType Type)
Get the total size of all Type sections.
Definition: SampleProfReader.cpp:1232
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:861
llvm::sampleprof::FunctionSamples
Representation of the samples collected for a function.
Definition: SampleProf.h:691
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:726
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFileNames
static const uint32_t GCOVTagAFDOFileNames
GCOV tags used to separate sections in the profile file.
Definition: SampleProfReader.h:895
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: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:863
llvm::DenseMap
Definition: DenseMap.h:714
llvm::sampleprof::SampleProfileReader::profileIsCSFlat
bool profileIsCSFlat() const
Whether input profile is fully context-sensitive and flat.
Definition: SampleProfReader.h:477
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:266
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:460
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:1707
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncMetadata
std::error_code readFuncMetadata(bool ProfileHasAttribute)
Definition: SampleProfReader.cpp:1145
llvm::sampleprof::HIST_TYPE_AVERAGE
@ HIST_TYPE_AVERAGE
Definition: SampleProfReader.h:856
llvm::sampleprof::FunctionSamples::UseMD5
static bool UseMD5
Whether the profile uses MD5 to represent string.
Definition: SampleProf.h:1060
llvm::sampleprof::SampleProfileReaderGCC::readString
ErrorOr< StringRef > readString()
Definition: SampleProfReader.cpp:1504
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:1787
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:286
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:1323
llvm::sampleprof::SampleProfileReaderGCC::GCOVTagAFDOFunction
static const uint32_t GCOVTagAFDOFunction
Definition: SampleProfReader.h:896
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:811
llvm::sampleprof::SampleProfileReader::hasUniqSuffix
virtual bool hasUniqSuffix()
Return whether any name in the profile contains ".__uniq." suffix.
Definition: SampleProfReader.h:498
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readImpl
std::error_code readImpl() override
Read sample profiles in extensible format from the associated file.
Definition: SampleProfReader.cpp:895
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
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
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:1897
llvm::sampleprof::HIST_TYPE_INTERVAL
@ HIST_TYPE_INTERVAL
Definition: SampleProfReader.h:851
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:598
llvm::sampleprof::SampleProfileReader::getSummary
ProfileSummary & getSummary() const
Return the profile summary.
Definition: SampleProfReader.h:466
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: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: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:1481
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:1422
llvm::sampleprof::SampleProfileReaderGCC::readHeader
std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1511
llvm::sampleprof::SampleProfileReaderCompactBinary::useMD5
virtual bool useMD5() override
Return whether names in the profile are all MD5 numbers.
Definition: SampleProfReader.h:843
llvm::sampleprof::HIST_TYPE_SINGLE_VALUE
@ HIST_TYPE_SINGLE_VALUE
Definition: SampleProfReader.h:853
llvm::sampleprof::SampleProfileReaderExtBinaryBase::FuncsToUse
DenseSet< StringRef > FuncsToUse
The set containing the functions to use when compiling a module.
Definition: SampleProfReader.h:737
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:1241
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
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1217
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:858
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:427
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:957
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:392
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:610
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncProfiles
std::error_code readFuncProfiles()
Definition: SampleProfReader.cpp:755
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:1395
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::SampleProfileReader::ProfileIsCSFlat
bool ProfileIsCSFlat
Whether function profiles are context-sensitive flat profiles.
Definition: SampleProfReader.h:540
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readOneSection
virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size, const SecHdrTableEntry &Entry)
Definition: SampleProfReader.cpp:646
llvm::sampleprof::SampleProfileReaderExtBinaryBase::readFuncOffsetTable
std::error_code readFuncOffsetTable()
Definition: SampleProfReader.cpp:720
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:855
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:1474
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
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:1304
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::sampleprof::HIST_TYPE_POW2
@ HIST_TYPE_POW2
Definition: SampleProfReader.h:852
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:1467
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:1707
llvm::sampleprof::SampleProfileReaderBinary::readStringIndex
ErrorOr< uint32_t > readStringIndex(T &Table)
Read the string index and check whether it overflows the table.
Definition: SampleProfReader.cpp:442
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
virtual std::error_code readHeader() override
Read and validate the file header.
Definition: SampleProfReader.cpp:1341
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:828
llvm::sampleprof::HistType
HistType
Definition: SampleProfReader.h:850
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:711
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