LLVM  6.0.0svn
InstrProf.h
Go to the documentation of this file.
1 //===- InstrProf.h - Instrumented profiling format support ------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // Instrumentation-based profiling data is generated by instrumented
11 // binaries through library functions in compiler-rt, and read by the clang
12 // frontend to feed PGO.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_PROFILEDATA_INSTRPROF_H
17 #define LLVM_PROFILEDATA_INSTRPROF_H
18 
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/ADT/StringRef.h"
22 #include "llvm/ADT/StringSet.h"
23 #include "llvm/ADT/Triple.h"
24 #include "llvm/IR/GlobalValue.h"
25 #include "llvm/IR/ProfileSummary.h"
27 #include "llvm/Support/Compiler.h"
28 #include "llvm/Support/Endian.h"
29 #include "llvm/Support/Error.h"
31 #include "llvm/Support/Host.h"
32 #include "llvm/Support/MD5.h"
35 #include <algorithm>
36 #include <cassert>
37 #include <cstddef>
38 #include <cstdint>
39 #include <cstring>
40 #include <list>
41 #include <memory>
42 #include <string>
43 #include <system_error>
44 #include <utility>
45 #include <vector>
46 
47 namespace llvm {
48 
49 class Function;
50 class GlobalVariable;
51 struct InstrProfRecord;
52 class InstrProfSymtab;
53 class Instruction;
54 class MDNode;
55 class Module;
56 
58 #define INSTR_PROF_SECT_ENTRY(Kind, SectNameCommon, SectNameCoff, Prefix) Kind,
60 };
61 
62 /// Return the name of the profile section corresponding to \p IPSK.
63 ///
64 /// The name of the section depends on the object format type \p OF. If
65 /// \p AddSegmentInfo is true, a segment prefix and additional linker hints may
66 /// be added to the section name (this is the default).
69  bool AddSegmentInfo = true);
70 
71 /// Return the name profile runtime entry point to do value profiling
72 /// for a given site.
74  return INSTR_PROF_VALUE_PROF_FUNC_STR;
75 }
76 
77 /// Return the name profile runtime entry point to do value range profiling.
79  return INSTR_PROF_VALUE_RANGE_PROF_FUNC_STR;
80 }
81 
82 /// Return the name prefix of variables containing instrumented function names.
83 inline StringRef getInstrProfNameVarPrefix() { return "__profn_"; }
84 
85 /// Return the name prefix of variables containing per-function control data.
86 inline StringRef getInstrProfDataVarPrefix() { return "__profd_"; }
87 
88 /// Return the name prefix of profile counter variables.
89 inline StringRef getInstrProfCountersVarPrefix() { return "__profc_"; }
90 
91 /// Return the name prefix of value profile variables.
92 inline StringRef getInstrProfValuesVarPrefix() { return "__profvp_"; }
93 
94 /// Return the name of value profile node array variables:
95 inline StringRef getInstrProfVNodesVarName() { return "__llvm_prf_vnodes"; }
96 
97 /// Return the name prefix of the COMDAT group for instrumentation variables
98 /// associated with a COMDAT function.
99 inline StringRef getInstrProfComdatPrefix() { return "__profv_"; }
100 
101 /// Return the name of the variable holding the strings (possibly compressed)
102 /// of all function's PGO names.
104  return "__llvm_prf_nm";
105 }
106 
107 /// Return the name of a covarage mapping variable (internal linkage)
108 /// for each instrumented source module. Such variables are allocated
109 /// in the __llvm_covmap section.
111  return "__llvm_coverage_mapping";
112 }
113 
114 /// Return the name of the internal variable recording the array
115 /// of PGO name vars referenced by the coverage mapping. The owning
116 /// functions of those names are not emitted by FE (e.g, unused inline
117 /// functions.)
119  return "__llvm_coverage_names";
120 }
121 
122 /// Return the name of function that registers all the per-function control
123 /// data at program startup time by calling __llvm_register_function. This
124 /// function has internal linkage and is called by __llvm_profile_init
125 /// runtime method. This function is not generated for these platforms:
126 /// Darwin, Linux, and FreeBSD.
128  return "__llvm_profile_register_functions";
129 }
130 
131 /// Return the name of the runtime interface that registers per-function control
132 /// data for one instrumented function.
134  return "__llvm_profile_register_function";
135 }
136 
137 /// Return the name of the runtime interface that registers the PGO name strings.
139  return "__llvm_profile_register_names_function";
140 }
141 
142 /// Return the name of the runtime initialization method that is generated by
143 /// the compiler. The function calls __llvm_profile_register_functions and
144 /// __llvm_profile_override_default_filename functions if needed. This function
145 /// has internal linkage and invoked at startup time via init_array.
146 inline StringRef getInstrProfInitFuncName() { return "__llvm_profile_init"; }
147 
148 /// Return the name of the hook variable defined in profile runtime library.
149 /// A reference to the variable causes the linker to link in the runtime
150 /// initialization module (which defines the hook variable).
152  return INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_RUNTIME_VAR);
153 }
154 
155 /// Return the name of the compiler generated function that references the
156 /// runtime hook variable. The function is a weak global.
158  return "__llvm_profile_runtime_user";
159 }
160 
161 /// Return the marker used to separate PGO names during serialization.
162 inline StringRef getInstrProfNameSeparator() { return "\01"; }
163 
164 /// Return the modified name for function \c F suitable to be
165 /// used the key for profile lookup. Variable \c InLTO indicates if this
166 /// is called in LTO optimization passes.
167 std::string getPGOFuncName(const Function &F, bool InLTO = false,
168  uint64_t Version = INSTR_PROF_INDEX_VERSION);
169 
170 /// Return the modified name for a function suitable to be
171 /// used the key for profile lookup. The function's original
172 /// name is \c RawFuncName and has linkage of type \c Linkage.
173 /// The function is defined in module \c FileName.
174 std::string getPGOFuncName(StringRef RawFuncName,
176  StringRef FileName,
177  uint64_t Version = INSTR_PROF_INDEX_VERSION);
178 
179 /// Return the name of the global variable used to store a function
180 /// name in PGO instrumentation. \c FuncName is the name of the function
181 /// returned by the \c getPGOFuncName call.
182 std::string getPGOFuncNameVarName(StringRef FuncName,
183  GlobalValue::LinkageTypes Linkage);
184 
185 /// Create and return the global variable for function name used in PGO
186 /// instrumentation. \c FuncName is the name of the function returned
187 /// by \c getPGOFuncName call.
189 
190 /// Create and return the global variable for function name used in PGO
191 /// instrumentation. /// \c FuncName is the name of the function
192 /// returned by \c getPGOFuncName call, \c M is the owning module,
193 /// and \c Linkage is the linkage of the instrumented function.
196  StringRef PGOFuncName);
197 
198 /// Return the initializer in string of the PGO name var \c NameVar.
200 
201 /// Given a PGO function name, remove the filename prefix and return
202 /// the original (static) function name.
204  StringRef FileName = "<unknown>");
205 
206 /// Given a vector of strings (function PGO names) \c NameStrs, the
207 /// method generates a combined string \c Result thatis ready to be
208 /// serialized. The \c Result string is comprised of three fields:
209 /// The first field is the legnth of the uncompressed strings, and the
210 /// the second field is the length of the zlib-compressed string.
211 /// Both fields are encoded in ULEB128. If \c doCompress is false, the
212 /// third field is the uncompressed strings; otherwise it is the
213 /// compressed string. When the string compression is off, the
214 /// second field will have value zero.
216  bool doCompression, std::string &Result);
217 
218 /// Produce \c Result string with the same format described above. The input
219 /// is vector of PGO function name variables that are referenced.
221  std::string &Result, bool doCompression = true);
222 
223 /// \c NameStrings is a string composed of one of more sub-strings encoded in
224 /// the format described above. The substrings are separated by 0 or more zero
225 /// bytes. This method decodes the string and populates the \c Symtab.
227 
228 /// Check if INSTR_PROF_RAW_VERSION_VAR is defined. This global is only being
229 /// set in IR PGO compilation.
230 bool isIRPGOFlagSet(const Module *M);
231 
232 /// Check if we can safely rename this Comdat function. Instances of the same
233 /// comdat function may have different control flows thus can not share the
234 /// same counter variable.
235 bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken = false);
236 
238 #define VALUE_PROF_KIND(Enumerator, Value) Enumerator = Value,
240 };
241 
242 /// Get the value profile data for value site \p SiteIdx from \p InstrProfR
243 /// and annotate the instruction \p Inst with the value profile meta data.
244 /// Annotate up to \p MaxMDCount (default 3) number of records per value site.
245 void annotateValueSite(Module &M, Instruction &Inst,
246  const InstrProfRecord &InstrProfR,
248  uint32_t MaxMDCount = 3);
249 
250 /// Same as the above interface but using an ArrayRef, as well as \p Sum.
251 void annotateValueSite(Module &M, Instruction &Inst,
252  ArrayRef<InstrProfValueData> VDs, uint64_t Sum,
254 
255 /// Extract the value profile data from \p Inst which is annotated with
256 /// value profile meta data. Return false if there is no value data annotated,
257 /// otherwise return true.
258 bool getValueProfDataFromInst(const Instruction &Inst,
260  uint32_t MaxNumValueData,
261  InstrProfValueData ValueData[],
262  uint32_t &ActualNumValueData, uint64_t &TotalC);
263 
264 inline StringRef getPGOFuncNameMetadataName() { return "PGOFuncName"; }
265 
266 /// Return the PGOFuncName meta data associated with a function.
268 
269 /// Create the PGOFuncName meta data if PGOFuncName is different from
270 /// function's raw name. This should only apply to internal linkage functions
271 /// declared by users only.
272 void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName);
273 
274 /// Check if we can use Comdat for profile variables. This will eliminate
275 /// the duplicated profile variables for Comdat functions.
276 bool needsComdatForCounter(const Function &F, const Module &M);
277 
279 
280 enum class instrprof_error {
281  success = 0,
282  eof,
284  bad_magic,
285  bad_header,
288  too_large,
289  truncated,
290  malformed,
300 };
301 
302 inline std::error_code make_error_code(instrprof_error E) {
303  return std::error_code(static_cast<int>(E), instrprof_category());
304 }
305 
306 class InstrProfError : public ErrorInfo<InstrProfError> {
307 public:
308  InstrProfError(instrprof_error Err) : Err(Err) {
309  assert(Err != instrprof_error::success && "Not an error");
310  }
311 
312  std::string message() const override;
313 
314  void log(raw_ostream &OS) const override { OS << message(); }
315 
316  std::error_code convertToErrorCode() const override {
317  return make_error_code(Err);
318  }
319 
320  instrprof_error get() const { return Err; }
321 
322  /// Consume an Error and return the raw enum value contained within it. The
323  /// Error must either be a success value, or contain a single InstrProfError.
325  auto Err = instrprof_error::success;
326  handleAllErrors(std::move(E), [&Err](const InstrProfError &IPE) {
327  assert(Err == instrprof_error::success && "Multiple errors encountered");
328  Err = IPE.get();
329  });
330  return Err;
331  }
332 
333  static char ID;
334 
335 private:
336  instrprof_error Err;
337 };
338 
340  /// Count the number of soft instrprof_errors encountered and keep track of
341  /// the first such error for reporting purposes.
342 
343  /// The first soft error encountered.
345 
346  /// The number of hash mismatches.
347  unsigned NumHashMismatches = 0;
348 
349  /// The number of count mismatches.
350  unsigned NumCountMismatches = 0;
351 
352  /// The number of counter overflows.
353  unsigned NumCounterOverflows = 0;
354 
355  /// The number of value site count mismatches.
356  unsigned NumValueSiteCountMismatches = 0;
357 
358 public:
359  SoftInstrProfErrors() = default;
360 
362  assert(FirstError == instrprof_error::success &&
363  "Unchecked soft error encountered");
364  }
365 
366  /// Track a soft error (\p IE) and increment its associated counter.
367  void addError(instrprof_error IE);
368 
369  /// Get the number of hash mismatches.
370  unsigned getNumHashMismatches() const { return NumHashMismatches; }
371 
372  /// Get the number of count mismatches.
373  unsigned getNumCountMismatches() const { return NumCountMismatches; }
374 
375  /// Get the number of counter overflows.
376  unsigned getNumCounterOverflows() const { return NumCounterOverflows; }
377 
378  /// Get the number of value site count mismatches.
380  return NumValueSiteCountMismatches;
381  }
382 
383  /// Return the first encountered error and reset FirstError to a success
384  /// value.
386  if (FirstError == instrprof_error::success)
387  return Error::success();
388  auto E = make_error<InstrProfError>(FirstError);
389  FirstError = instrprof_error::success;
390  return E;
391  }
392 };
393 
394 namespace object {
395 
396 class SectionRef;
397 
398 } // end namespace object
399 
400 namespace IndexedInstrProf {
401 
402 uint64_t ComputeHash(StringRef K);
403 
404 } // end namespace IndexedInstrProf
405 
406 /// A symbol table used for function PGO name look-up with keys
407 /// (such as pointers, md5hash values) to the function. A function's
408 /// PGO name or name's md5hash are used in retrieving the profile
409 /// data of the function. See \c getPGOFuncName() method for details
410 /// on how PGO name is formed.
412 public:
413  using AddrHashMap = std::vector<std::pair<uint64_t, uint64_t>>;
414 
415 private:
416  StringRef Data;
417  uint64_t Address = 0;
418  // Unique name strings.
419  StringSet<> NameTab;
420  // A map from MD5 keys to function name strings.
421  std::vector<std::pair<uint64_t, StringRef>> MD5NameMap;
422  // A map from MD5 keys to function define. We only populate this map
423  // when build the Symtab from a Module.
424  std::vector<std::pair<uint64_t, Function *>> MD5FuncMap;
425  // A map from function runtime address to function name MD5 hash.
426  // This map is only populated and used by raw instr profile reader.
427  AddrHashMap AddrToMD5Map;
428 
429 public:
430  InstrProfSymtab() = default;
431 
432  /// Create InstrProfSymtab from an object file section which
433  /// contains function PGO names. When section may contain raw
434  /// string data or string data in compressed form. This method
435  /// only initialize the symtab with reference to the data and
436  /// the section base address. The decompression will be delayed
437  /// until before it is used. See also \c create(StringRef) method.
439 
440  /// This interface is used by reader of CoverageMapping test
441  /// format.
442  inline Error create(StringRef D, uint64_t BaseAddr);
443 
444  /// \c NameStrings is a string composed of one of more sub-strings
445  /// encoded in the format described in \c collectPGOFuncNameStrings.
446  /// This method is a wrapper to \c readPGOFuncNameStrings method.
447  inline Error create(StringRef NameStrings);
448 
449  /// A wrapper interface to populate the PGO symtab with functions
450  /// decls from module \c M. This interface is used by transformation
451  /// passes such as indirect function call promotion. Variable \c InLTO
452  /// indicates if this is called from LTO optimization passes.
453  Error create(Module &M, bool InLTO = false);
454 
455  /// Create InstrProfSymtab from a set of names iteratable from
456  /// \p IterRange. This interface is used by IndexedProfReader.
457  template <typename NameIterRange> Error create(const NameIterRange &IterRange);
458 
459  // If the symtab is created by a series of calls to \c addFuncName, \c
460  // finalizeSymtab needs to be called before looking up function names.
461  // This is required because the underlying map is a vector (for space
462  // efficiency) which needs to be sorted.
463  inline void finalizeSymtab();
464 
465  /// Update the symtab by adding \p FuncName to the table. This interface
466  /// is used by the raw and text profile readers.
468  if (FuncName.empty())
469  return make_error<InstrProfError>(instrprof_error::malformed);
470  auto Ins = NameTab.insert(FuncName);
471  if (Ins.second)
472  MD5NameMap.push_back(std::make_pair(
473  IndexedInstrProf::ComputeHash(FuncName), Ins.first->getKey()));
474  return Error::success();
475  }
476 
477  /// Map a function address to its name's MD5 hash. This interface
478  /// is only used by the raw profiler reader.
479  void mapAddress(uint64_t Addr, uint64_t MD5Val) {
480  AddrToMD5Map.push_back(std::make_pair(Addr, MD5Val));
481  }
482 
483  AddrHashMap &getAddrHashMap() { return AddrToMD5Map; }
484 
485  /// Return function's PGO name from the function name's symbol
486  /// address in the object file. If an error occurs, return
487  /// an empty string.
488  StringRef getFuncName(uint64_t FuncNameAddress, size_t NameSize);
489 
490  /// Return function's PGO name from the name's md5 hash value.
491  /// If not found, return an empty string.
492  inline StringRef getFuncName(uint64_t FuncMD5Hash);
493 
494  /// Return function from the name's md5 hash. Return nullptr if not found.
495  inline Function *getFunction(uint64_t FuncMD5Hash);
496 
497  /// Return the function's original assembly name by stripping off
498  /// the prefix attached (to symbols with priviate linkage). For
499  /// global functions, it returns the same string as getFuncName.
500  inline StringRef getOrigFuncName(uint64_t FuncMD5Hash);
501 
502  /// Return the name section data.
503  inline StringRef getNameData() const { return Data; }
504 };
505 
507  Data = D;
508  Address = BaseAddr;
509  return Error::success();
510 }
511 
513  return readPGOFuncNameStrings(NameStrings, *this);
514 }
515 
516 template <typename NameIterRange>
517 Error InstrProfSymtab::create(const NameIterRange &IterRange) {
518  for (auto Name : IterRange)
519  if (Error E = addFuncName(Name))
520  return E;
521 
522  finalizeSymtab();
523  return Error::success();
524 }
525 
527  std::sort(MD5NameMap.begin(), MD5NameMap.end(), less_first());
528  std::sort(MD5FuncMap.begin(), MD5FuncMap.end(), less_first());
529  std::sort(AddrToMD5Map.begin(), AddrToMD5Map.end(), less_first());
530  AddrToMD5Map.erase(std::unique(AddrToMD5Map.begin(), AddrToMD5Map.end()),
531  AddrToMD5Map.end());
532 }
533 
535  auto Result =
536  std::lower_bound(MD5NameMap.begin(), MD5NameMap.end(), FuncMD5Hash,
537  [](const std::pair<uint64_t, std::string> &LHS,
538  uint64_t RHS) { return LHS.first < RHS; });
539  if (Result != MD5NameMap.end() && Result->first == FuncMD5Hash)
540  return Result->second;
541  return StringRef();
542 }
543 
544 Function* InstrProfSymtab::getFunction(uint64_t FuncMD5Hash) {
545  auto Result =
546  std::lower_bound(MD5FuncMap.begin(), MD5FuncMap.end(), FuncMD5Hash,
547  [](const std::pair<uint64_t, Function*> &LHS,
548  uint64_t RHS) { return LHS.first < RHS; });
549  if (Result != MD5FuncMap.end() && Result->first == FuncMD5Hash)
550  return Result->second;
551  return nullptr;
552 }
553 
554 // See also getPGOFuncName implementation. These two need to be
555 // matched.
557  StringRef PGOName = getFuncName(FuncMD5Hash);
558  size_t S = PGOName.find_first_of(':');
559  if (S == StringRef::npos)
560  return PGOName;
561  return PGOName.drop_front(S + 1);
562 }
563 
565  /// Value profiling data pairs at a given value site.
566  std::list<InstrProfValueData> ValueData;
567 
568  InstrProfValueSiteRecord() { ValueData.clear(); }
569  template <class InputIterator>
570  InstrProfValueSiteRecord(InputIterator F, InputIterator L)
571  : ValueData(F, L) {}
572 
573  /// Sort ValueData ascending by Value
575  ValueData.sort(
576  [](const InstrProfValueData &left, const InstrProfValueData &right) {
577  return left.Value < right.Value;
578  });
579  }
580  /// Sort ValueData Descending by Count
581  inline void sortByCount();
582 
583  /// Merge data from another InstrProfValueSiteRecord
584  /// Optionally scale merged counts by \p Weight.
585  void merge(InstrProfValueSiteRecord &Input, uint64_t Weight,
586  function_ref<void(instrprof_error)> Warn);
587  /// Scale up value profile data counts.
588  void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
589 };
590 
591 /// Profiling information for a single function.
593  std::vector<uint64_t> Counts;
594 
595  InstrProfRecord() = default;
596  InstrProfRecord(std::vector<uint64_t> Counts) : Counts(std::move(Counts)) {}
597  InstrProfRecord(InstrProfRecord &&) = default;
599  : Counts(RHS.Counts),
600  ValueData(RHS.ValueData
601  ? llvm::make_unique<ValueProfData>(*RHS.ValueData)
602  : nullptr) {}
603  InstrProfRecord &operator=(InstrProfRecord &&) = default;
605  Counts = RHS.Counts;
606  if (!RHS.ValueData) {
607  ValueData = nullptr;
608  return *this;
609  }
610  if (!ValueData)
611  ValueData = llvm::make_unique<ValueProfData>(*RHS.ValueData);
612  else
613  *ValueData = *RHS.ValueData;
614  return *this;
615  }
616 
617  using ValueMapType = std::vector<std::pair<uint64_t, uint64_t>>;
618 
619  /// Return the number of value profile kinds with non-zero number
620  /// of profile sites.
621  inline uint32_t getNumValueKinds() const;
622  /// Return the number of instrumented sites for ValueKind.
623  inline uint32_t getNumValueSites(uint32_t ValueKind) const;
624 
625  /// Return the total number of ValueData for ValueKind.
626  inline uint32_t getNumValueData(uint32_t ValueKind) const;
627 
628  /// Return the number of value data collected for ValueKind at profiling
629  /// site: Site.
630  inline uint32_t getNumValueDataForSite(uint32_t ValueKind,
631  uint32_t Site) const;
632 
633  /// Return the array of profiled values at \p Site. If \p TotalC
634  /// is not null, the total count of all target values at this site
635  /// will be stored in \c *TotalC.
636  inline std::unique_ptr<InstrProfValueData[]>
637  getValueForSite(uint32_t ValueKind, uint32_t Site,
638  uint64_t *TotalC = nullptr) const;
639 
640  /// Get the target value/counts of kind \p ValueKind collected at site
641  /// \p Site and store the result in array \p Dest. Return the total
642  /// counts of all target values at this site.
643  inline uint64_t getValueForSite(InstrProfValueData Dest[], uint32_t ValueKind,
644  uint32_t Site) const;
645 
646  /// Reserve space for NumValueSites sites.
647  inline void reserveSites(uint32_t ValueKind, uint32_t NumValueSites);
648 
649  /// Add ValueData for ValueKind at value Site.
650  void addValueData(uint32_t ValueKind, uint32_t Site,
651  InstrProfValueData *VData, uint32_t N,
653 
654  /// Merge the counts in \p Other into this one.
655  /// Optionally scale merged counts by \p Weight.
656  void merge(InstrProfRecord &Other, uint64_t Weight,
657  function_ref<void(instrprof_error)> Warn);
658 
659  /// Scale up profile counts (including value profile data) by
660  /// \p Weight.
661  void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
662 
663  /// Sort value profile data (per site) by count.
664  void sortValueData() {
665  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
666  for (auto &SR : getValueSitesForKind(Kind))
667  SR.sortByCount();
668  }
669 
670  /// Clear value data entries and edge counters.
671  void Clear() {
672  Counts.clear();
673  clearValueData();
674  }
675 
676  /// Clear value data entries
677  void clearValueData() { ValueData = nullptr; }
678 
679 private:
680  struct ValueProfData {
681  std::vector<InstrProfValueSiteRecord> IndirectCallSites;
682  std::vector<InstrProfValueSiteRecord> MemOPSizes;
683  };
684  std::unique_ptr<ValueProfData> ValueData;
685 
687  getValueSitesForKind(uint32_t ValueKind) {
688  // Cast to /add/ const (should be an implicit_cast, ideally, if that's ever
689  // implemented in LLVM) to call the const overload of this function, then
690  // cast away the constness from the result.
691  auto AR = const_cast<const InstrProfRecord *>(this)->getValueSitesForKind(
692  ValueKind);
693  return makeMutableArrayRef(
694  const_cast<InstrProfValueSiteRecord *>(AR.data()), AR.size());
695  }
697  getValueSitesForKind(uint32_t ValueKind) const {
698  if (!ValueData)
699  return None;
700  switch (ValueKind) {
701  case IPVK_IndirectCallTarget:
702  return ValueData->IndirectCallSites;
703  case IPVK_MemOPSize:
704  return ValueData->MemOPSizes;
705  default:
706  llvm_unreachable("Unknown value kind!");
707  }
708  }
709 
710  std::vector<InstrProfValueSiteRecord> &
711  getOrCreateValueSitesForKind(uint32_t ValueKind) {
712  if (!ValueData)
713  ValueData = llvm::make_unique<ValueProfData>();
714  switch (ValueKind) {
715  case IPVK_IndirectCallTarget:
716  return ValueData->IndirectCallSites;
717  case IPVK_MemOPSize:
718  return ValueData->MemOPSizes;
719  default:
720  llvm_unreachable("Unknown value kind!");
721  }
722  }
723 
724  // Map indirect call target name hash to name string.
725  uint64_t remapValue(uint64_t Value, uint32_t ValueKind,
726  ValueMapType *HashKeys);
727 
728  // Merge Value Profile data from Src record to this record for ValueKind.
729  // Scale merged value counts by \p Weight.
730  void mergeValueProfData(uint32_t ValkeKind, InstrProfRecord &Src,
731  uint64_t Weight,
732  function_ref<void(instrprof_error)> Warn);
733 
734  // Scale up value profile data count.
735  void scaleValueProfData(uint32_t ValueKind, uint64_t Weight,
736  function_ref<void(instrprof_error)> Warn);
737 };
738 
741  uint64_t Hash;
742 
743  NamedInstrProfRecord() = default;
744  NamedInstrProfRecord(StringRef Name, uint64_t Hash,
745  std::vector<uint64_t> Counts)
746  : InstrProfRecord(std::move(Counts)), Name(Name), Hash(Hash) {}
747 };
748 
750  uint32_t NumValueKinds = 0;
751  for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
752  NumValueKinds += !(getValueSitesForKind(Kind).empty());
753  return NumValueKinds;
754 }
755 
757  uint32_t N = 0;
758  for (auto &SR : getValueSitesForKind(ValueKind))
759  N += SR.ValueData.size();
760  return N;
761 }
762 
764  return getValueSitesForKind(ValueKind).size();
765 }
766 
768  uint32_t Site) const {
769  return getValueSitesForKind(ValueKind)[Site].ValueData.size();
770 }
771 
772 std::unique_ptr<InstrProfValueData[]>
774  uint64_t *TotalC) const {
775  uint64_t Dummy;
776  uint64_t &TotalCount = (TotalC == nullptr ? Dummy : *TotalC);
777  uint32_t N = getNumValueDataForSite(ValueKind, Site);
778  if (N == 0) {
779  TotalCount = 0;
780  return std::unique_ptr<InstrProfValueData[]>(nullptr);
781  }
782 
783  auto VD = llvm::make_unique<InstrProfValueData[]>(N);
784  TotalCount = getValueForSite(VD.get(), ValueKind, Site);
785 
786  return VD;
787 }
788 
789 uint64_t InstrProfRecord::getValueForSite(InstrProfValueData Dest[],
791  uint32_t Site) const {
792  uint32_t I = 0;
793  uint64_t TotalCount = 0;
794  for (auto V : getValueSitesForKind(ValueKind)[Site].ValueData) {
795  Dest[I].Value = V.Value;
796  Dest[I].Count = V.Count;
797  TotalCount = SaturatingAdd(TotalCount, V.Count);
798  I++;
799  }
800  return TotalCount;
801 }
802 
804  if (!NumValueSites)
805  return;
806  getOrCreateValueSitesForKind(ValueKind).reserve(NumValueSites);
807 }
808 
811 }
812 
813 // Include definitions for value profile data
814 #define INSTR_PROF_VALUE_PROF_DATA
816 
818  ValueData.sort(
819  [](const InstrProfValueData &left, const InstrProfValueData &right) {
820  return left.Count > right.Count;
821  });
822  // Now truncate
823  size_t max_s = INSTR_PROF_MAX_NUM_VAL_PER_SITE;
824  if (ValueData.size() > max_s)
825  ValueData.resize(max_s);
826 }
827 
828 namespace IndexedInstrProf {
829 
830 enum class HashT : uint32_t {
831  MD5,
832  Last = MD5
833 };
834 
835 inline uint64_t ComputeHash(HashT Type, StringRef K) {
836  switch (Type) {
837  case HashT::MD5:
838  return MD5Hash(K);
839  }
840  llvm_unreachable("Unhandled hash type");
841 }
842 
843 const uint64_t Magic = 0x8169666f72706cff; // "\xfflprofi\x81"
844 
846  // Version 1 is the first version. In this version, the value of
847  // a key/value pair can only include profile data of a single function.
848  // Due to this restriction, the number of block counters for a given
849  // function is not recorded but derived from the length of the value.
850  Version1 = 1,
851  // The version 2 format supports recording profile data of multiple
852  // functions which share the same key in one value field. To support this,
853  // the number block counters is recorded as an uint64_t field right after the
854  // function structural hash.
855  Version2 = 2,
856  // Version 3 supports value profile data. The value profile data is expected
857  // to follow the block counter profile data.
858  Version3 = 3,
859  // In this version, profile summary data \c IndexedInstrProf::Summary is
860  // stored after the profile header.
861  Version4 = 4,
862  // In this version, the frontend PGO stable hash algorithm defaults to V2.
863  Version5 = 5,
864  // The current version is 5.
865  CurrentVersion = INSTR_PROF_INDEX_VERSION
866 };
868 
869 const HashT HashType = HashT::MD5;
870 
871 inline uint64_t ComputeHash(StringRef K) { return ComputeHash(HashType, K); }
872 
873 // This structure defines the file header of the LLVM profile
874 // data file in indexed-format.
875 struct Header {
876  uint64_t Magic;
877  uint64_t Version;
878  uint64_t Unused; // Becomes unused since version 4
879  uint64_t HashType;
880  uint64_t HashOffset;
881 };
882 
883 // Profile summary data recorded in the profile data file in indexed
884 // format. It is introduced in version 4. The summary data follows
885 // right after the profile file header.
886 struct Summary {
887  struct Entry {
888  uint64_t Cutoff; ///< The required percentile of total execution count.
889  uint64_t
890  MinBlockCount; ///< The minimum execution count for this percentile.
891  uint64_t NumBlocks; ///< Number of blocks >= the minumum execution count.
892  };
893  // The field kind enumerator to assigned value mapping should remain
894  // unchanged when a new kind is added or an old kind gets deleted in
895  // the future.
897  /// The total number of functions instrumented.
898  TotalNumFunctions = 0,
899  /// Total number of instrumented blocks/edges.
900  TotalNumBlocks = 1,
901  /// The maximal execution count among all functions.
902  /// This field does not exist for profile data from IR based
903  /// instrumentation.
904  MaxFunctionCount = 2,
905  /// Max block count of the program.
906  MaxBlockCount = 3,
907  /// Max internal block count of the program (excluding entry blocks).
908  MaxInternalBlockCount = 4,
909  /// The sum of all instrumented block counts.
910  TotalBlockCount = 5,
911  NumKinds = TotalBlockCount + 1
912  };
913 
914  // The number of summmary fields following the summary header.
916  // The number of Cutoff Entries (Summary::Entry) following summary fields.
918 
919  Summary() = delete;
920  Summary(uint32_t Size) { memset(this, 0, Size); }
921 
922  void operator delete(void *ptr) { ::operator delete(ptr); }
923 
924  static uint32_t getSize(uint32_t NumSumFields, uint32_t NumCutoffEntries) {
925  return sizeof(Summary) + NumCutoffEntries * sizeof(Entry) +
926  NumSumFields * sizeof(uint64_t);
927  }
928 
929  const uint64_t *getSummaryDataBase() const {
930  return reinterpret_cast<const uint64_t *>(this + 1);
931  }
932 
933  uint64_t *getSummaryDataBase() {
934  return reinterpret_cast<uint64_t *>(this + 1);
935  }
936 
937  const Entry *getCutoffEntryBase() const {
938  return reinterpret_cast<const Entry *>(
939  &getSummaryDataBase()[NumSummaryFields]);
940  }
941 
943  return reinterpret_cast<Entry *>(&getSummaryDataBase()[NumSummaryFields]);
944  }
945 
946  uint64_t get(SummaryFieldKind K) const {
947  return getSummaryDataBase()[K];
948  }
949 
950  void set(SummaryFieldKind K, uint64_t V) {
951  getSummaryDataBase()[K] = V;
952  }
953 
954  const Entry &getEntry(uint32_t I) const { return getCutoffEntryBase()[I]; }
955 
957  Entry &ER = getCutoffEntryBase()[I];
958  ER.Cutoff = E.Cutoff;
959  ER.MinBlockCount = E.MinCount;
960  ER.NumBlocks = E.NumCounts;
961  }
962 };
963 
964 inline std::unique_ptr<Summary> allocSummary(uint32_t TotalSize) {
965  return std::unique_ptr<Summary>(new (::operator new(TotalSize))
966  Summary(TotalSize));
967 }
968 
969 } // end namespace IndexedInstrProf
970 
971 namespace RawInstrProf {
972 
973 // Version 1: First version
974 // Version 2: Added value profile data section. Per-function control data
975 // struct has more fields to describe value profile information.
976 // Version 3: Compressed name section support. Function PGO name reference
977 // from control data struct is changed from raw pointer to Name's MD5 value.
978 // Version 4: ValueDataBegin and ValueDataSizes fields are removed from the
979 // raw header.
980 const uint64_t Version = INSTR_PROF_RAW_VERSION;
981 
982 template <class IntPtrT> inline uint64_t getMagic();
983 template <> inline uint64_t getMagic<uint64_t>() {
984  return INSTR_PROF_RAW_MAGIC_64;
985 }
986 
987 template <> inline uint64_t getMagic<uint32_t>() {
988  return INSTR_PROF_RAW_MAGIC_32;
989 }
990 
991 // Per-function profile data header/control structure.
992 // The definition should match the structure defined in
993 // compiler-rt/lib/profile/InstrProfiling.h.
994 // It should also match the synthesized type in
995 // Transforms/Instrumentation/InstrProfiling.cpp:getOrCreateRegionCounters.
996 template <class IntPtrT> struct LLVM_ALIGNAS(8) ProfileData {
997  #define INSTR_PROF_DATA(Type, LLVMType, Name, Init) Type Name;
999 };
1000 
1001 // File header structure of the LLVM profile data in raw format.
1002 // The definition should match the header referenced in
1003 // compiler-rt/lib/profile/InstrProfilingFile.c and
1004 // InstrProfilingBuffer.c.
1005 struct Header {
1006 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) const Type Name;
1008 };
1009 
1010 } // end namespace RawInstrProf
1011 
1012 // Parse MemOP Size range option.
1013 void getMemOPSizeRangeFromOption(StringRef Str, int64_t &RangeStart,
1014  int64_t &RangeLast);
1015 
1016 } // end namespace llvm
1017 
1018 #endif // LLVM_PROFILEDATA_INSTRPROF_H
void log(raw_ostream &OS) const override
Print an error message to an output stream.
Definition: InstrProf.h:314
StringRef getInstrProfRuntimeHookVarUseFuncName()
Return the name of the compiler generated function that references the runtime hook variable...
Definition: InstrProf.h:157
A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the...
Definition: InstrProf.h:411
static uint32_t getSize(uint32_t NumSumFields, uint32_t NumCutoffEntries)
Definition: InstrProf.h:924
void sortByCount()
Sort ValueData Descending by Count.
Definition: InstrProf.h:817
uint32_t Cutoff
The required percentile of counts.
MutableArrayRef< T > makeMutableArrayRef(T &OneElt)
Construct a MutableArrayRef from a single element.
Definition: ArrayRef.h:503
StringRef getInstrProfNameVarPrefix()
Return the name prefix of variables containing instrumented function names.
Definition: InstrProf.h:83
uint64_t getMagic()
void sortValueData()
Sort value profile data (per site) by count.
Definition: InstrProf.h:664
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
uint64_t MinBlockCount
The minimum execution count for this percentile.
Definition: InstrProf.h:890
StringRef getOrigFuncName(uint64_t FuncMD5Hash)
Return the function&#39;s original assembly name by stripping off the prefix attached (to symbols with pr...
Definition: InstrProf.h:556
StringRef getInstrProfRegFuncsName()
Return the name of function that registers all the per-function control data at program startup time ...
Definition: InstrProf.h:127
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
uint32_t getNumValueDataForSite(uint32_t ValueKind, uint32_t Site) const
Return the number of value data collected for ValueKind at profiling site: Site.
Definition: InstrProf.h:767
void setEntry(uint32_t I, const ProfileSummaryEntry &E)
Definition: InstrProf.h:956
static instrprof_error take(Error E)
Consume an Error and return the raw enum value contained within it.
Definition: InstrProf.h:324
bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken=false)
Check if we can safely rename this Comdat function.
Definition: InstrProf.cpp:971
MDNode * getPGOFuncNameMetadata(const Function &F)
Return the PGOFuncName meta data associated with a function.
Definition: InstrProf.cpp:908
uint64_t MD5Hash(StringRef Str)
Helper to compute and return lower 64 bits of the given string&#39;s MD5 hash.
Definition: MD5.h:109
Function * getFunction(uint64_t FuncMD5Hash)
Return function from the name&#39;s md5 hash. Return nullptr if not found.
Definition: InstrProf.h:544
uint64_t getMagic< uint64_t >()
Definition: InstrProf.h:983
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:89
AddrHashMap & getAddrHashMap()
Definition: InstrProf.h:483
NamedInstrProfRecord(StringRef Name, uint64_t Hash, std::vector< uint64_t > Counts)
Definition: InstrProf.h:744
std::unique_ptr< Summary > allocSummary(uint32_t TotalSize)
Definition: InstrProf.h:964
uint32_t getNumValueData(uint32_t ValueKind) const
Return the total number of ValueData for ValueKind.
Definition: InstrProf.h:756
Metadata node.
Definition: Metadata.h:862
std::string getInstrProfSectionName(InstrProfSectKind IPSK, Triple::ObjectFormatType OF, bool AddSegmentInfo=true)
Return the name of the profile section corresponding to IPSK.
Definition: InstrProf.cpp:165
F(f)
std::enable_if<!std::is_array< T >::value, std::unique_ptr< T > >::type make_unique(Args &&... args)
Constructs a new T() with the given args and returns a unique_ptr<T> which owns the object...
Definition: STLExtras.h:899
StringRef getInstrProfValuesVarPrefix()
Return the name prefix of value profile variables.
Definition: InstrProf.h:92
void reserveSites(uint32_t ValueKind, uint32_t NumValueSites)
Reserve space for NumValueSites sites.
Definition: InstrProf.h:803
std::enable_if< std::is_unsigned< T >::value, T >::type SaturatingAdd(T X, T Y, bool *ResultOverflowed=nullptr)
Add two unsigned integers, X and Y, of type T.
Definition: MathExtras.h:768
uint32_t getNumValueSites(uint32_t ValueKind) const
Return the number of instrumented sites for ValueKind.
Definition: InstrProf.h:763
unsigned getNumValueSiteCountMismatches() const
Get the number of value site count mismatches.
Definition: InstrProf.h:379
const Entry & getEntry(uint32_t I) const
Definition: InstrProf.h:954
StringRef getInstrProfInitFuncName()
Return the name of the runtime initialization method that is generated by the compiler.
Definition: InstrProf.h:146
Definition: BitVector.h:920
const HashT HashType
Definition: InstrProf.h:869
StringRef getInstrProfDataVarPrefix()
Return the name prefix of variables containing per-function control data.
Definition: InstrProf.h:86
const std::error_category & instrprof_category()
Definition: InstrProf.cpp:137
InstrProfValueKind
Definition: InstrProf.h:237
std::error_code make_error_code(BitcodeError E)
Error collectPGOFuncNameStrings(ArrayRef< std::string > NameStrs, bool doCompression, std::string &Result)
Given a vector of strings (function PGO names) NameStrs, the method generates a combined string Resul...
Definition: InstrProf.cpp:363
uint64_t ComputeHash(HashT Type, StringRef K)
Definition: InstrProf.h:835
StringRef getCoverageUnusedNamesVarName()
Return the name of the internal variable recording the array of PGO name vars referenced by the cover...
Definition: InstrProf.h:118
InstrProfSectKind
Definition: InstrProf.h:57
void mapAddress(uint64_t Addr, uint64_t MD5Val)
Map a function address to its name&#39;s MD5 hash.
Definition: InstrProf.h:479
StringRef getInstrProfNamesRegFuncName()
Return the name of the runtime interface that registers the PGO name strings.
Definition: InstrProf.h:138
static const bool IsLittleEndianHost
Definition: Host.h:50
StringRef getFuncNameWithoutPrefix(StringRef PGOFuncName, StringRef FileName="<unknown>")
Given a PGO function name, remove the filename prefix and return the original (static) function name...
Definition: InstrProf.cpp:275
StringRef getFuncName(uint64_t FuncNameAddress, size_t NameSize)
Return function&#39;s PGO name from the function name&#39;s symbol address in the object file.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:133
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
StringRef getInstrProfNameSeparator()
Return the marker used to separate PGO names during serialization.
Definition: InstrProf.h:162
InstrProfRecord(const InstrProfRecord &RHS)
Definition: InstrProf.h:598
const uint64_t Version
Definition: InstrProf.h:980
uint64_t NumBlocks
Number of blocks >= the minumum execution count.
Definition: InstrProf.h:891
instrprof_error get() const
Definition: InstrProf.h:320
bool isIRPGOFlagSet(const Module *M)
Check if INSTR_PROF_RAW_VERSION_VAR is defined.
Definition: InstrProf.cpp:951
unsigned getNumCountMismatches() const
Get the number of count mismatches.
Definition: InstrProf.h:373
uint64_t getMagic< uint32_t >()
Definition: InstrProf.h:987
void getMemOPSizeRangeFromOption(StringRef Str, int64_t &RangeStart, int64_t &RangeLast)
Definition: InstrProf.cpp:994
bool needsComdatForCounter(const Function &F, const Module &M)
Check if we can use Comdat for profile variables.
Definition: InstrProf.cpp:924
bool getValueProfDataFromInst(const Instruction &Inst, InstrProfValueKind ValueKind, uint32_t MaxNumValueData, InstrProfValueData ValueData[], uint32_t &ActualNumValueData, uint64_t &TotalC)
Extract the value profile data from Inst which is annotated with value profile meta data...
Definition: InstrProf.cpp:856
MutableArrayRef - Represent a mutable reference to an array (0 or more elements consecutively in memo...
Definition: ArrayRef.h:291
std::string getPGOFuncNameVarName(StringRef FuncName, GlobalValue::LinkageTypes Linkage)
Return the name of the global variable used to store a function name in PGO instrumentation.
Definition: InstrProf.cpp:286
uint64_t Cutoff
The required percentile of total execution count.
Definition: InstrProf.h:888
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
const uint64_t * getSummaryDataBase() const
Definition: InstrProf.h:929
StringRef getInstrProfValueProfFuncName()
Return the name profile runtime entry point to do value profiling for a given site.
Definition: InstrProf.h:73
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
ValueKind
Value kinds.
StringRef getInstrProfNamesVarName()
Return the name of the variable holding the strings (possibly compressed) of all function&#39;s PGO names...
Definition: InstrProf.h:103
unsigned getNumCounterOverflows() const
Get the number of counter overflows.
Definition: InstrProf.h:376
std::vector< std::pair< uint64_t, uint64_t > > ValueMapType
Definition: InstrProf.h:617
static ManagedStatic< _object_error_category > error_category
Definition: Error.cpp:74
uint32_t getNumValueKinds() const
Return the number of value profile kinds with non-zero number of profile sites.
Definition: InstrProf.h:749
std::list< InstrProfValueData > ValueData
Value profiling data pairs at a given value site.
Definition: InstrProf.h:566
static uint64_t scale(uint64_t Num, uint32_t N, uint32_t D)
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:871
void annotateValueSite(Module &M, Instruction &Inst, const InstrProfRecord &InstrProfR, InstrProfValueKind ValueKind, uint32_t SiteIndx, uint32_t MaxMDCount=3)
Get the value profile data for value site SiteIdx from InstrProfR and annotate the instruction Inst w...
Definition: InstrProf.cpp:811
const Entry * getCutoffEntryBase() const
Definition: InstrProf.h:937
void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName)
Create the PGOFuncName meta data if PGOFuncName is different from function&#39;s raw name.
Definition: InstrProf.cpp:912
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab)
NameStrings is a string composed of one of more sub-strings encoded in the format described above...
Definition: InstrProf.cpp:421
std::pair< typename base::iterator, bool > insert(StringRef Key)
Definition: StringSet.h:38
unsigned getNumHashMismatches() const
Get the number of hash mismatches.
Definition: InstrProf.h:370
Error takeError()
Return the first encountered error and reset FirstError to a success value.
Definition: InstrProf.h:385
StringRef getInstrProfCountersVarPrefix()
Return the name prefix of profile counter variables.
Definition: InstrProf.h:89
void clearValueData()
Clear value data entries.
Definition: InstrProf.h:677
static const char *const Magic
Definition: Archive.cpp:42
InstrProfRecord(std::vector< uint64_t > Counts)
Definition: InstrProf.h:596
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef drop_front(size_t N=1) const
Return a StringRef equal to &#39;this&#39; but with the first N elements dropped.
Definition: StringRef.h:645
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that it requires that all errors be handled by the given han...
Definition: Error.h:889
static ErrorSuccess success()
Create a success value.
Definition: Error.h:313
StringRef getCoverageMappingVarName()
Return the name of a covarage mapping variable (internal linkage) for each instrumented source module...
Definition: InstrProf.h:110
See the file comment.
Definition: ValueMap.h:86
StringRef getPGOFuncNameMetadataName()
Definition: InstrProf.h:264
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
LinkageTypes
An enumeration for the kinds of linkage for global values.
Definition: GlobalValue.h:48
static char ID
Definition: InstrProf.h:333
StringRef getInstrProfRuntimeHookVarName()
Return the name of the hook variable defined in profile runtime library.
Definition: InstrProf.h:151
StringRef getInstrProfRegFuncName()
Return the name of the runtime interface that registers per-function control data for one instrumente...
Definition: InstrProf.h:133
auto lower_bound(R &&Range, ForwardIt I) -> decltype(std::begin(Range))
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:859
Base class for user error types.
Definition: Error.h:331
void sortByTargetValues()
Sort ValueData ascending by Value.
Definition: InstrProf.h:574
std::vector< uint64_t > Counts
Definition: InstrProf.h:593
static const size_t npos
Definition: StringRef.h:51
#define LLVM_ALIGNAS(x)
LLVM_ALIGNAS
Definition: Compiler.h:322
Profiling information for a single function.
Definition: InstrProf.h:592
StringRef getNameData() const
Return the name section data.
Definition: InstrProf.h:503
std::string getPGOFuncName(const Function &F, bool InLTO=false, uint64_t Version=INSTR_PROF_INDEX_VERSION)
Return the modified name for function F suitable to be used the key for profile lookup.
Definition: InstrProf.cpp:253
instrprof_error
Definition: InstrProf.h:280
Error addFuncName(StringRef FuncName)
Update the symtab by adding FuncName to the table.
Definition: InstrProf.h:467
LLVM_NODISCARD size_t find_first_of(char C, size_t From=0) const
Find the first character in the string that is C, or npos if not found.
Definition: StringRef.h:395
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
GlobalVariable * createPGOFuncNameVar(Function &F, StringRef PGOFuncName)
Create and return the global variable for function name used in PGO instrumentation.
Definition: InstrProf.cpp:331
Definition: MD5.h:41
InstrProfValueSiteRecord(InputIterator F, InputIterator L)
Definition: InstrProf.h:570
const unsigned Kind
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef getInstrProfValueRangeProfFuncName()
Return the name profile runtime entry point to do value range profiling.
Definition: InstrProf.h:78
ObjectFormatType
Definition: Triple.h:211
LLVM Value Representation.
Definition: Value.h:73
constexpr char Size[]
Key for Kernel::Arg::Metadata::mSize.
StringRef getInstrProfVNodesVarName()
Return the name of value profile node array variables:
Definition: InstrProf.h:95
std::vector< std::pair< uint64_t, uint64_t > > AddrHashMap
Definition: InstrProf.h:413
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
uint64_t MinCount
The minimum count for this percentile.
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:28
support::endianness getHostEndianness()
Definition: InstrProf.h:809
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
InstrProfRecord & operator=(const InstrProfRecord &RHS)
Definition: InstrProf.h:604
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
std::unique_ptr< InstrProfValueData[]> getValueForSite(uint32_t ValueKind, uint32_t Site, uint64_t *TotalC=nullptr) const
Return the array of profiled values at Site.
Definition: InstrProf.h:773
uint64_t NumCounts
Number of counts >= the minimum count.
StringRef getInstrProfComdatPrefix()
Return the name prefix of the COMDAT group for instrumentation variables associated with a COMDAT fun...
Definition: InstrProf.h:99
void sort(Policy policy, RandomAccessIterator Start, RandomAccessIterator End, const Comparator &Comp=Comparator())
Definition: Parallel.h:199
std::error_code convertToErrorCode() const override
Convert this error to a std::error_code.
Definition: InstrProf.h:316
InstrProfError(instrprof_error Err)
Definition: InstrProf.h:308
Function object to check whether the first component of a std::pair compares less than the first comp...
Definition: STLExtras.h:603
void Clear()
Clear value data entries and edge counters.
Definition: InstrProf.h:671
StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar)
Return the initializer in string of the PGO name var NameVar.
Definition: InstrProf.cpp:404
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:80