LLVM  10.0.0svn
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 //
31 // This is a nested tree in which the identation represents the nesting level
32 // of the inline stack. There are no blank lines in the file. And the spacing
33 // within a single line is fixed. Additional spaces will result in an error
34 // while reading the file.
35 //
36 // Any line starting with the '#' character is completely ignored.
37 //
38 // Inlined calls are represented with indentation. The Inline stack is a
39 // stack of source locations in which the top of the stack represents the
40 // leaf function, and the bottom of the stack represents the actual
41 // symbol to which the instruction belongs.
42 //
43 // Function names must be mangled in order for the profile loader to
44 // match them in the current translation unit. The two numbers in the
45 // function header specify how many total samples were accumulated in the
46 // function (first number), and the total number of samples accumulated
47 // in the prologue of the function (second number). This head sample
48 // count provides an indicator of how frequently the function is invoked.
49 //
50 // There are two types of lines in the function body.
51 //
52 // * Sampled line represents the profile information of a source location.
53 // * Callsite line represents the profile information of a callsite.
54 //
55 // Each sampled line may contain several items. Some are optional (marked
56 // below):
57 //
58 // a. Source line offset. This number represents the line number
59 // in the function where the sample was collected. The line number is
60 // always relative to the line where symbol of the function is
61 // defined. So, if the function has its header at line 280, the offset
62 // 13 is at line 293 in the file.
63 //
64 // Note that this offset should never be a negative number. This could
65 // happen in cases like macros. The debug machinery will register the
66 // line number at the point of macro expansion. So, if the macro was
67 // expanded in a line before the start of the function, the profile
68 // converter should emit a 0 as the offset (this means that the optimizers
69 // will not be able to associate a meaningful weight to the instructions
70 // in the macro).
71 //
72 // b. [OPTIONAL] Discriminator. This is used if the sampled program
73 // was compiled with DWARF discriminator support
74 // (http://wiki.dwarfstd.org/index.php?title=Path_Discriminators).
75 // DWARF discriminators are unsigned integer values that allow the
76 // compiler to distinguish between multiple execution paths on the
77 // same source line location.
78 //
79 // For example, consider the line of code ``if (cond) foo(); else bar();``.
80 // If the predicate ``cond`` is true 80% of the time, then the edge
81 // into function ``foo`` should be considered to be taken most of the
82 // time. But both calls to ``foo`` and ``bar`` are at the same source
83 // line, so a sample count at that line is not sufficient. The
84 // compiler needs to know which part of that line is taken more
85 // frequently.
86 //
87 // This is what discriminators provide. In this case, the calls to
88 // ``foo`` and ``bar`` will be at the same line, but will have
89 // different discriminator values. This allows the compiler to correctly
90 // set edge weights into ``foo`` and ``bar``.
91 //
92 // c. Number of samples. This is an integer quantity representing the
93 // number of samples collected by the profiler at this source
94 // location.
95 //
96 // d. [OPTIONAL] Potential call targets and samples. If present, this
97 // line contains a call instruction. This models both direct and
98 // number of samples. For example,
99 //
100 // 130: 7 foo:3 bar:2 baz:7
101 //
102 // The above means that at relative line offset 130 there is a call
103 // instruction that calls one of ``foo()``, ``bar()`` and ``baz()``,
104 // with ``baz()`` being the relatively more frequently called target.
105 //
106 // Each callsite line may contain several items. Some are optional.
107 //
108 // a. Source line offset. This number represents the line number of the
109 // callsite that is inlined in the profiled binary.
110 //
111 // b. [OPTIONAL] Discriminator. Same as the discriminator for sampled line.
112 //
113 // c. Number of samples. This is an integer quantity representing the
114 // total number of samples collected for the inlined instance at this
115 // callsite
116 //
117 //
118 // Binary format
119 // -------------
120 //
121 // This is a more compact encoding. Numbers are encoded as ULEB128 values
122 // and all strings are encoded in a name table. The file is organized in
123 // the following sections:
124 //
125 // MAGIC (uint64_t)
126 // File identifier computed by function SPMagic() (0x5350524f463432ff)
127 //
128 // VERSION (uint32_t)
129 // File format version number computed by SPVersion()
130 //
131 // SUMMARY
132 // TOTAL_COUNT (uint64_t)
133 // Total number of samples in the profile.
134 // MAX_COUNT (uint64_t)
135 // Maximum value of samples on a line.
136 // MAX_FUNCTION_COUNT (uint64_t)
137 // Maximum number of samples at function entry (head samples).
138 // NUM_COUNTS (uint64_t)
139 // Number of lines with samples.
140 // NUM_FUNCTIONS (uint64_t)
141 // Number of functions with samples.
142 // NUM_DETAILED_SUMMARY_ENTRIES (size_t)
143 // Number of entries in detailed summary
144 // DETAILED_SUMMARY
145 // A list of detailed summary entry. Each entry consists of
146 // CUTOFF (uint32_t)
147 // Required percentile of total sample count expressed as a fraction
148 // multiplied by 1000000.
149 // MIN_COUNT (uint64_t)
150 // The minimum number of samples required to reach the target
151 // CUTOFF.
152 // NUM_COUNTS (uint64_t)
153 // Number of samples to get to the desrired percentile.
154 //
155 // NAME TABLE
156 // SIZE (uint32_t)
157 // Number of entries in the name table.
158 // NAMES
159 // A NUL-separated list of SIZE strings.
160 //
161 // FUNCTION BODY (one for each uninlined function body present in the profile)
162 // HEAD_SAMPLES (uint64_t) [only for top-level functions]
163 // Total number of samples collected at the head (prologue) of the
164 // function.
165 // NOTE: This field should only be present for top-level functions
166 // (i.e., not inlined into any caller). Inlined function calls
167 // have no prologue, so they don't need this.
168 // NAME_IDX (uint32_t)
169 // Index into the name table indicating the function name.
170 // SAMPLES (uint64_t)
171 // Total number of samples collected in this function.
172 // NRECS (uint32_t)
173 // Total number of sampling records this function's profile.
174 // BODY RECORDS
175 // A list of NRECS entries. Each entry contains:
176 // OFFSET (uint32_t)
177 // Line offset from the start of the function.
178 // DISCRIMINATOR (uint32_t)
179 // Discriminator value (see description of discriminators
180 // in the text format documentation above).
181 // SAMPLES (uint64_t)
182 // Number of samples collected at this location.
183 // NUM_CALLS (uint32_t)
184 // Number of non-inlined function calls made at this location. In the
185 // case of direct calls, this number will always be 1. For indirect
186 // calls (virtual functions and function pointers) this will
187 // represent all the actual functions called at runtime.
188 // CALL_TARGETS
189 // A list of NUM_CALLS entries for each called function:
190 // NAME_IDX (uint32_t)
191 // Index into the name table with the callee name.
192 // SAMPLES (uint64_t)
193 // Number of samples collected at the call site.
194 // NUM_INLINED_FUNCTIONS (uint32_t)
195 // Number of callees inlined into this function.
196 // INLINED FUNCTION RECORDS
197 // A list of NUM_INLINED_FUNCTIONS entries describing each of the inlined
198 // callees.
199 // OFFSET (uint32_t)
200 // Line offset from the start of the function.
201 // DISCRIMINATOR (uint32_t)
202 // Discriminator value (see description of discriminators
203 // in the text format documentation above).
204 // FUNCTION BODY
205 // A FUNCTION BODY entry describing the inlined function.
206 //===----------------------------------------------------------------------===//
207 
208 #ifndef LLVM_PROFILEDATA_SAMPLEPROFREADER_H
209 #define LLVM_PROFILEDATA_SAMPLEPROFREADER_H
210 
211 #include "llvm/ADT/SmallVector.h"
212 #include "llvm/ADT/StringMap.h"
213 #include "llvm/ADT/StringRef.h"
214 #include "llvm/ADT/Twine.h"
215 #include "llvm/IR/DiagnosticInfo.h"
216 #include "llvm/IR/Function.h"
217 #include "llvm/IR/LLVMContext.h"
218 #include "llvm/IR/ProfileSummary.h"
219 #include "llvm/ProfileData/GCOV.h"
221 #include "llvm/Support/Debug.h"
222 #include "llvm/Support/ErrorOr.h"
225 #include <algorithm>
226 #include <cstdint>
227 #include <memory>
228 #include <string>
229 #include <system_error>
230 #include <vector>
231 
232 namespace llvm {
233 
234 class raw_ostream;
235 
236 namespace sampleprof {
237 
238 class SampleProfileReader;
239 
240 /// SampleProfileReaderItaniumRemapper remaps the profile data from a
241 /// sample profile data reader, by applying a provided set of equivalences
242 /// between components of the symbol names in the profile.
244 public:
245  SampleProfileReaderItaniumRemapper(std::unique_ptr<MemoryBuffer> B,
246  std::unique_ptr<SymbolRemappingReader> SRR,
248  : Buffer(std::move(B)), Remappings(std::move(SRR)), Reader(R) {
249  assert(Remappings && "Remappings cannot be nullptr");
250  }
251 
252  /// Create a remapper from the given remapping file. The remapper will
253  /// be used for profile read in by Reader.
255  create(const std::string Filename, SampleProfileReader &Reader,
256  LLVMContext &C);
257 
258  /// Create a remapper from the given Buffer. The remapper will
259  /// be used for profile read in by Reader.
261  create(std::unique_ptr<MemoryBuffer> &B, SampleProfileReader &Reader,
262  LLVMContext &C);
263 
264  /// Apply remappings to the profile read by Reader.
265  void applyRemapping(LLVMContext &Ctx);
266 
267  bool hasApplied() { return RemappingApplied; }
268 
269  /// Insert function name into remapper.
270  void insert(StringRef FunctionName) { Remappings->insert(FunctionName); }
271 
272  /// Query whether there is equivalent in the remapper which has been
273  /// inserted.
274  bool exist(StringRef FunctionName) {
275  return Remappings->lookup(FunctionName);
276  }
277 
278  /// Return the samples collected for function \p F if remapper knows
279  /// it is present in SampleMap.
280  FunctionSamples *getSamplesFor(StringRef FunctionName);
281 
282 private:
283  // The buffer holding the content read from remapping file.
284  std::unique_ptr<MemoryBuffer> Buffer;
285  std::unique_ptr<SymbolRemappingReader> Remappings;
287  // The Reader the remapper is servicing.
288  SampleProfileReader &Reader;
289  // Indicate whether remapping has been applied to the profile read
290  // by Reader -- by calling applyRemapping.
291  bool RemappingApplied = false;
292 };
293 
294 /// Sample-based profile reader.
295 ///
296 /// Each profile contains sample counts for all the functions
297 /// executed. Inside each function, statements are annotated with the
298 /// collected samples on all the instructions associated with that
299 /// statement.
300 ///
301 /// For this to produce meaningful data, the program needs to be
302 /// compiled with some debug information (at minimum, line numbers:
303 /// -gline-tables-only). Otherwise, it will be impossible to match IR
304 /// instructions to the line numbers collected by the profiler.
305 ///
306 /// From the profile file, we are interested in collecting the
307 /// following information:
308 ///
309 /// * A list of functions included in the profile (mangled names).
310 ///
311 /// * For each function F:
312 /// 1. The total number of samples collected in F.
313 ///
314 /// 2. The samples collected at each line in F. To provide some
315 /// protection against source code shuffling, line numbers should
316 /// be relative to the start of the function.
317 ///
318 /// The reader supports two file formats: text and binary. The text format
319 /// is useful for debugging and testing, while the binary format is more
320 /// compact and I/O efficient. They can both be used interchangeably.
322 public:
323  SampleProfileReader(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
324  SampleProfileFormat Format = SPF_None)
325  : Profiles(0), Ctx(C), Buffer(std::move(B)), Format(Format) {}
326 
327  virtual ~SampleProfileReader() = default;
328 
329  /// Read and validate the file header.
330  virtual std::error_code readHeader() = 0;
331 
332  /// The interface to read sample profiles from the associated file.
333  std::error_code read() {
334  if (std::error_code EC = readImpl())
335  return EC;
336  if (Remapper)
337  Remapper->applyRemapping(Ctx);
339  }
340 
341  /// The implementaion to read sample profiles from the associated file.
342  virtual std::error_code readImpl() = 0;
343 
344  /// Print the profile for \p FName on stream \p OS.
345  void dumpFunctionProfile(StringRef FName, raw_ostream &OS = dbgs());
346 
347  virtual void collectFuncsFrom(const Module &M) {}
348 
349  /// Print all the profiles on stream \p OS.
350  void dump(raw_ostream &OS = dbgs());
351 
352  /// Return the samples collected for function \p F.
354  // The function name may have been updated by adding suffix. Call
355  // a helper to (optionally) strip off suffixes so that we can
356  // match against the original function name in the profile.
358  return getSamplesFor(CanonName);
359  }
360 
361  /// Return the samples collected for function \p F.
363  if (Remapper) {
364  if (auto FS = Remapper->getSamplesFor(Fname))
365  return FS;
366  }
367  std::string FGUID;
368  Fname = getRepInFormat(Fname, getFormat(), FGUID);
369  auto It = Profiles.find(Fname);
370  if (It != Profiles.end())
371  return &It->second;
372  return nullptr;
373  }
374 
375  /// Return all the profiles.
376  StringMap<FunctionSamples> &getProfiles() { return Profiles; }
377 
378  /// Report a parse error message.
379  void reportError(int64_t LineNumber, Twine Msg) const {
380  Ctx.diagnose(DiagnosticInfoSampleProfile(Buffer->getBufferIdentifier(),
381  LineNumber, Msg));
382  }
383 
384  /// Create a sample profile reader appropriate to the file format.
385  /// Create a remapper underlying if RemapFilename is not empty.
387  create(const std::string Filename, LLVMContext &C,
388  const std::string RemapFilename = "");
389 
390  /// Create a sample profile reader from the supplied memory buffer.
391  /// Create a remapper underlying if RemapFilename is not empty.
393  create(std::unique_ptr<MemoryBuffer> &B, LLVMContext &C,
394  const std::string RemapFilename = "");
395 
396  /// Return the profile summary.
397  ProfileSummary &getSummary() const { return *(Summary.get()); }
398 
399  MemoryBuffer *getBuffer() const { return Buffer.get(); }
400 
401  /// \brief Return the profile format.
402  SampleProfileFormat getFormat() const { return Format; }
403 
404  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() {
405  return nullptr;
406  };
407 
408  /// It includes all the names that have samples either in outline instance
409  /// or inline instance.
410  virtual std::vector<StringRef> *getNameTable() { return nullptr; }
411  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) { return false; };
412 
413 protected:
414  /// Map every function to its associated profile.
415  ///
416  /// The profile of every function executed at runtime is collected
417  /// in the structure FunctionSamples. This maps function objects
418  /// to their corresponding profiles.
420 
421  /// LLVM context used to emit diagnostics.
423 
424  /// Memory buffer holding the profile file.
425  std::unique_ptr<MemoryBuffer> Buffer;
426 
427  /// Profile summary information.
428  std::unique_ptr<ProfileSummary> Summary;
429 
430  /// Take ownership of the summary of this reader.
431  static std::unique_ptr<ProfileSummary>
433  return std::move(Reader.Summary);
434  }
435 
436  /// Compute summary for this profile.
437  void computeSummary();
438 
439  std::unique_ptr<SampleProfileReaderItaniumRemapper> Remapper;
440 
441  /// \brief The format of sample.
443 };
444 
446 public:
447  SampleProfileReaderText(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
448  : SampleProfileReader(std::move(B), C, SPF_Text) {}
449 
450  /// Read and validate the file header.
451  std::error_code readHeader() override { return sampleprof_error::success; }
452 
453  /// Read sample profiles from the associated file.
454  std::error_code readImpl() override;
455 
456  /// Return true if \p Buffer is in the format supported by this class.
457  static bool hasFormat(const MemoryBuffer &Buffer);
458 };
459 
461 public:
462  SampleProfileReaderBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
463  SampleProfileFormat Format = SPF_None)
464  : SampleProfileReader(std::move(B), C, Format) {}
465 
466  /// Read and validate the file header.
467  virtual std::error_code readHeader() override;
468 
469  /// Read sample profiles from the associated file.
470  std::error_code readImpl() override;
471 
472  /// It includes all the names that have samples either in outline instance
473  /// or inline instance.
474  virtual std::vector<StringRef> *getNameTable() override { return &NameTable; }
475 
476 protected:
477  /// Read a numeric value of type T from the profile.
478  ///
479  /// If an error occurs during decoding, a diagnostic message is emitted and
480  /// EC is set.
481  ///
482  /// \returns the read value.
483  template <typename T> ErrorOr<T> readNumber();
484 
485  /// Read a numeric value of type T from the profile. The value is saved
486  /// without encoded.
487  template <typename T> ErrorOr<T> readUnencodedNumber();
488 
489  /// Read a string from the profile.
490  ///
491  /// If an error occurs during decoding, a diagnostic message is emitted and
492  /// EC is set.
493  ///
494  /// \returns the read value.
496 
497  /// Read the string index and check whether it overflows the table.
498  template <typename T> inline ErrorOr<uint32_t> readStringIndex(T &Table);
499 
500  /// Return true if we've reached the end of file.
501  bool at_eof() const { return Data >= End; }
502 
503  /// Read the next function profile instance.
504  std::error_code readFuncProfile(const uint8_t *Start);
505 
506  /// Read the contents of the given profile instance.
507  std::error_code readProfile(FunctionSamples &FProfile);
508 
509  /// Read the contents of Magic number and Version number.
510  std::error_code readMagicIdent();
511 
512  /// Read profile summary.
513  std::error_code readSummary();
514 
515  /// Read the whole name table.
516  virtual std::error_code readNameTable();
517 
518  /// Points to the current location in the buffer.
519  const uint8_t *Data = nullptr;
520 
521  /// Points to the end of the buffer.
522  const uint8_t *End = nullptr;
523 
524  /// Function name table.
525  std::vector<StringRef> NameTable;
526 
527  /// Read a string indirectly via the name table.
528  virtual ErrorOr<StringRef> readStringFromTable();
529 
530 private:
531  std::error_code readSummaryEntry(std::vector<ProfileSummaryEntry> &Entries);
532  virtual std::error_code verifySPMagic(uint64_t Magic) = 0;
533 };
534 
536 private:
537  virtual std::error_code verifySPMagic(uint64_t Magic) override;
538 
539 public:
540  SampleProfileReaderRawBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
542  : SampleProfileReaderBinary(std::move(B), C, Format) {}
543 
544  /// \brief Return true if \p Buffer is in the format supported by this class.
545  static bool hasFormat(const MemoryBuffer &Buffer);
546 };
547 
548 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines
549 /// the basic structure of the extensible binary format.
550 /// The format is organized in sections except the magic and version number
551 /// at the beginning. There is a section table before all the sections, and
552 /// each entry in the table describes the entry type, start, size and
553 /// attributes. The format in each section is defined by the section itself.
554 ///
555 /// It is easy to add a new section while maintaining the backward
556 /// compatibility of the profile. Nothing extra needs to be done. If we want
557 /// to extend an existing section, like add cache misses information in
558 /// addition to the sample count in the profile body, we can add a new section
559 /// with the extension and retire the existing section, and we could choose
560 /// to keep the parser of the old section if we want the reader to be able
561 /// to read both new and old format profile.
562 ///
563 /// SampleProfileReaderExtBinary/SampleProfileWriterExtBinary define the
564 /// commonly used sections of a profile in extensible binary format. It is
565 /// possible to define other types of profile inherited from
566 /// SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase.
568 private:
569  std::error_code decompressSection(const uint8_t *SecStart,
570  const uint64_t SecSize,
571  const uint8_t *&DecompressBuf,
572  uint64_t &DecompressBufSize);
573 
575 
576 protected:
577  std::vector<SecHdrTableEntry> SecHdrTable;
578  std::unique_ptr<ProfileSymbolList> ProfSymList;
579  std::error_code readSecHdrTableEntry();
580  std::error_code readSecHdrTable();
581  virtual std::error_code readHeader() override;
582  virtual std::error_code verifySPMagic(uint64_t Magic) override = 0;
583  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
584  SecType Type) = 0;
585 
586 public:
587  SampleProfileReaderExtBinaryBase(std::unique_ptr<MemoryBuffer> B,
588  LLVMContext &C, SampleProfileFormat Format)
589  : SampleProfileReaderBinary(std::move(B), C, Format) {}
590 
591  /// Read sample profiles in extensible format from the associated file.
592  std::error_code readImpl() override;
593 
594  /// Get the total size of all \p Type sections.
595  uint64_t getSectionSize(SecType Type);
596  /// Get the total size of header and all sections.
597  uint64_t getFileSize();
598  virtual bool dumpSectionInfo(raw_ostream &OS = dbgs()) override;
599 };
600 
602 private:
603  virtual std::error_code verifySPMagic(uint64_t Magic) override;
604  virtual std::error_code readOneSection(const uint8_t *Start, uint64_t Size,
605  SecType Type) override;
606  std::error_code readProfileSymbolList();
607  std::error_code readFuncOffsetTable();
608  std::error_code readFuncProfiles();
609 
610  /// The table mapping from function name to the offset of its FunctionSample
611  /// towards file start.
612  DenseMap<StringRef, uint64_t> FuncOffsetTable;
613  /// The set containing the functions to use when compiling a module.
614  DenseSet<StringRef> FuncsToUse;
615  /// Use all functions from the input profile.
616  bool UseAllFuncs = true;
617 
618 public:
619  SampleProfileReaderExtBinary(std::unique_ptr<MemoryBuffer> B, LLVMContext &C,
621  : SampleProfileReaderExtBinaryBase(std::move(B), C, Format) {}
622 
623  /// \brief Return true if \p Buffer is in the format supported by this class.
624  static bool hasFormat(const MemoryBuffer &Buffer);
625 
626  virtual std::unique_ptr<ProfileSymbolList> getProfileSymbolList() override {
627  return std::move(ProfSymList);
628  };
629 
630  /// Collect functions with definitions in Module \p M.
631  void collectFuncsFrom(const Module &M) override;
632 };
633 
635 private:
636  /// Function name table.
637  std::vector<std::string> NameTable;
638  /// The table mapping from function name to the offset of its FunctionSample
639  /// towards file start.
640  DenseMap<StringRef, uint64_t> FuncOffsetTable;
641  /// The set containing the functions to use when compiling a module.
642  DenseSet<StringRef> FuncsToUse;
643  /// Use all functions from the input profile.
644  bool UseAllFuncs = true;
645  virtual std::error_code verifySPMagic(uint64_t Magic) override;
646  virtual std::error_code readNameTable() override;
647  /// Read a string indirectly via the name table.
648  virtual ErrorOr<StringRef> readStringFromTable() override;
649  virtual std::error_code readHeader() override;
650  std::error_code readFuncOffsetTable();
651 
652 public:
653  SampleProfileReaderCompactBinary(std::unique_ptr<MemoryBuffer> B,
654  LLVMContext &C)
656 
657  /// \brief Return true if \p Buffer is in the format supported by this class.
658  static bool hasFormat(const MemoryBuffer &Buffer);
659 
660  /// Read samples only for functions to use.
661  std::error_code readImpl() override;
662 
663  /// Collect functions to be used when compiling Module \p M.
664  void collectFuncsFrom(const Module &M) override;
665 };
666 
668 
669 // Supported histogram types in GCC. Currently, we only need support for
670 // call target histograms.
671 enum HistType {
680 };
681 
683 public:
684  SampleProfileReaderGCC(std::unique_ptr<MemoryBuffer> B, LLVMContext &C)
685  : SampleProfileReader(std::move(B), C, SPF_GCC),
686  GcovBuffer(Buffer.get()) {}
687 
688  /// Read and validate the file header.
689  std::error_code readHeader() override;
690 
691  /// Read sample profiles from the associated file.
692  std::error_code readImpl() override;
693 
694  /// Return true if \p Buffer is in the format supported by this class.
695  static bool hasFormat(const MemoryBuffer &Buffer);
696 
697 protected:
698  std::error_code readNameTable();
699  std::error_code readOneFunctionProfile(const InlineCallStack &InlineStack,
700  bool Update, uint32_t Offset);
701  std::error_code readFunctionProfiles();
702  std::error_code skipNextWord();
703  template <typename T> ErrorOr<T> readNumber();
705 
706  /// Read the section tag and check that it's the same as \p Expected.
707  std::error_code readSectionTag(uint32_t Expected);
708 
709  /// GCOV buffer containing the profile.
711 
712  /// Function names in this profile.
713  std::vector<std::string> Names;
714 
715  /// GCOV tags used to separate sections in the profile file.
716  static const uint32_t GCOVTagAFDOFileNames = 0xaa000000;
717  static const uint32_t GCOVTagAFDOFunction = 0xac000000;
718 };
719 
720 } // end namespace sampleprof
721 
722 } // end namespace llvm
723 
724 #endif // LLVM_PROFILEDATA_SAMPLEPROFREADER_H
std::vector< std::string > Names
Function names in this profile.
uint64_t CallInst * C
std::unique_ptr< MemoryBuffer > Buffer
Memory buffer holding the profile file.
Represents either an error or a value T.
Definition: ErrorOr.h:56
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static StringRef getRepInFormat(StringRef Name, SampleProfileFormat Format, std::string &GUIDBuf)
Definition: SampleProf.h:104
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
FunctionSamples * getSamplesFor(StringRef FunctionName)
Return the samples collected for function F if remapper knows it is present in SampleMap.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:249
virtual void collectFuncsFrom(const Module &M)
void applyRemapping(LLVMContext &Ctx)
Apply remappings to the profile read by Reader.
F(f)
bool exist(StringRef FunctionName)
Query whether there is equivalent in the remapper which has been inserted.
GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific read operations.
Definition: GCOV.h:67
Representation of the samples collected for a function.
Definition: SampleProf.h:300
Definition: BitVector.h:937
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
static std::unique_ptr< ProfileSummary > takeSummary(SampleProfileReader &Reader)
Take ownership of the summary of this reader.
SampleProfileReaderRawBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Binary)
StringMap< FunctionSamples > Profiles
Map every function to its associated profile.
SampleProfileReader(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
Tagged union holding either a T or a Error.
Definition: yaml2obj.h:21
SampleProfileReaderGCC(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
virtual FunctionSamples * getSamplesFor(StringRef Fname)
Return the samples collected for function F.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
static ErrorOr< std::unique_ptr< SampleProfileReaderItaniumRemapper > > create(const std::string Filename, SampleProfileReader &Reader, LLVMContext &C)
Create a remapper from the given remapping file.
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Allocate memory in an ever growing pool, as if by bump-pointer.
Definition: Allocator.h:141
FunctionSamples * getSamplesFor(const Function &F)
Return the samples collected for function F.
std::error_code read()
The interface to read sample profiles from the associated file.
LLVMContext & Ctx
LLVM context used to emit diagnostics.
SampleProfileReaderExtBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_Ext_Binary)
static StringRef getCanonicalFnName(const Function &F)
Return the canonical name for a function, taking into account suffix elision policy attributes...
Definition: SampleProf.h:499
SampleProfileReaderItaniumRemapper remaps the profile data from a sample profile data reader...
virtual std::vector< StringRef > * getNameTable() override
It includes all the names that have samples either in outline instance or inline instance.
SampleProfileReaderExtBinaryBase(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format)
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList() override
SampleProfileReaderExtBinaryBase/SampleProfileWriterExtBinaryBase defines the basic structure of the ...
static const char *const Magic
Definition: Archive.cpp:41
virtual std::unique_ptr< ProfileSymbolList > getProfileSymbolList()
Basic Register Allocator
std::unique_ptr< ProfileSymbolList > ProfSymList
bool at_eof() const
Return true if we&#39;ve reached the end of file.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
std::vector< StringRef > NameTable
Function name table.
SampleProfileReaderItaniumRemapper(std::unique_ptr< MemoryBuffer > B, std::unique_ptr< SymbolRemappingReader > SRR, SampleProfileReader &R)
virtual std::vector< StringRef > * getNameTable()
It includes all the names that have samples either in outline instance or inline instance.
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:41
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:242
static StringRef readString(WasmObjectFile::ReadContext &Ctx)
StringMap< FunctionSamples > & getProfiles()
Return all the profiles.
std::error_code readHeader() override
Read and validate the file header.
uint32_t Size
Definition: Profile.cpp:46
SampleProfileFormat getFormat() const
Return the profile format.
Provides ErrorOr<T> smart pointer.
ProfileSummary & getSummary() const
Return the profile summary.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
SampleProfileReaderText(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
SampleProfileReaderBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C, SampleProfileFormat Format=SPF_None)
void reportError(int64_t LineNumber, Twine Msg) const
Report a parse error message.
Sample-based profile reader.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
GCOVBuffer GcovBuffer
GCOV buffer containing the profile.
Diagnostic information for the sample profiler.
void insert(StringRef FunctionName)
Insert function name into remapper.
SampleProfileReaderCompactBinary(std::unique_ptr< MemoryBuffer > B, LLVMContext &C)
std::unique_ptr< ProfileSummary > Summary
Profile summary information.
std::unique_ptr< SampleProfileReaderItaniumRemapper > Remapper