[LangRef] Fix the doc for operand bundles
[oota-llvm.git] / include / llvm / ProfileData / InstrProf.h
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/StringRef.h"
20 #include "llvm/ADT/StringSet.h"
21 #include "llvm/Support/Endian.h"
22 #include "llvm/Support/ErrorHandling.h"
23 #include "llvm/Support/MD5.h"
24 #include <cstdint>
25 #include <list>
26 #include <system_error>
27 #include <vector>
28
29 namespace llvm {
30
31 inline StringRef getInstrProfCountersSectionName(bool AddSegment) {
32   return AddSegment ? "__DATA,__llvm_prf_cnts" : "__llvm_prf_cnts";
33 }
34
35 inline StringRef getInstrProfNameSectionName(bool AddSegment) {
36   return AddSegment ? "__DATA,__llvm_prf_names" : "__llvm_prf_names";
37 }
38
39 inline StringRef getInstrProfDataSectionName(bool AddSegment) {
40   return AddSegment ? "__DATA,__llvm_prf_data" : "__llvm_prf_data";
41 }
42
43 inline StringRef getInstrProfCoverageSectionName(bool AddSegment) {
44   return AddSegment ? "__DATA,__llvm_covmap" : "__llvm_covmap";
45 }
46
47 inline StringRef getInstrProfNameVarPrefix() { return "__llvm_profile_name_"; }
48
49 inline StringRef getInstrProfDataVarPrefix() { return "__llvm_profile_data_"; }
50
51 inline StringRef getInstrProfCountersVarPrefix() {
52   return "__llvm_profile_counters_";
53 }
54
55 inline StringRef getInstrProfComdatPrefix() { return "__llvm_profile_vars_"; }
56
57 inline StringRef getCoverageMappingVarName() {
58   return "__llvm_coverage_mapping";
59 }
60
61 const std::error_category &instrprof_category();
62
63 enum class instrprof_error {
64   success = 0,
65   eof,
66   bad_magic,
67   bad_header,
68   unsupported_version,
69   unsupported_hash_type,
70   too_large,
71   truncated,
72   malformed,
73   unknown_function,
74   hash_mismatch,
75   count_mismatch,
76   counter_overflow,
77   value_site_count_mismatch
78 };
79
80 inline std::error_code make_error_code(instrprof_error E) {
81   return std::error_code(static_cast<int>(E), instrprof_category());
82 }
83
84 enum InstrProfValueKind : uint32_t {
85   IPVK_IndirectCallTarget = 0,
86
87   IPVK_First = IPVK_IndirectCallTarget,
88   IPVK_Last = IPVK_IndirectCallTarget
89 };
90
91 struct InstrProfStringTable {
92   // Set of string values in profiling data.
93   StringSet<> StringValueSet;
94   InstrProfStringTable() { StringValueSet.clear(); }
95   // Get a pointer to internal storage of a string in set
96   const char *getStringData(StringRef Str) {
97     auto Result = StringValueSet.find(Str);
98     return (Result == StringValueSet.end()) ? nullptr : Result->first().data();
99   }
100   // Insert a string to StringTable
101   const char *insertString(StringRef Str) {
102     auto Result = StringValueSet.insert(Str);
103     return Result.first->first().data();
104   }
105 };
106
107 struct InstrProfValueSiteRecord {
108   /// Typedef for a single TargetValue-NumTaken pair.
109   typedef std::pair<uint64_t, uint64_t> ValueDataPair;
110   /// Value profiling data pairs at a given value site.
111   std::list<ValueDataPair> ValueData;
112
113   InstrProfValueSiteRecord() { ValueData.clear(); }
114
115   /// Sort ValueData ascending by TargetValue
116   void sortByTargetValues() {
117     ValueData.sort([](const ValueDataPair &left, const ValueDataPair &right) {
118       return left.first < right.first;
119     });
120   }
121
122   /// Merge data from another InstrProfValueSiteRecord
123   void mergeValueData(InstrProfValueSiteRecord &Input) {
124     this->sortByTargetValues();
125     Input.sortByTargetValues();
126     auto I = ValueData.begin();
127     auto IE = ValueData.end();
128     for (auto J = Input.ValueData.begin(), JE = Input.ValueData.end(); J != JE;
129          ++J) {
130       while (I != IE && I->first < J->first)
131         ++I;
132       if (I != IE && I->first == J->first) {
133         I->second += J->second;
134         ++I;
135         continue;
136       }
137       ValueData.insert(I, *J);
138     }
139   }
140 };
141
142 /// Profiling information for a single function.
143 struct InstrProfRecord {
144   InstrProfRecord() {}
145   InstrProfRecord(StringRef Name, uint64_t Hash, std::vector<uint64_t> Counts)
146       : Name(Name), Hash(Hash), Counts(std::move(Counts)) {}
147   StringRef Name;
148   uint64_t Hash;
149   std::vector<uint64_t> Counts;
150   std::vector<InstrProfValueSiteRecord> IndirectCallSites;
151
152   const std::vector<InstrProfValueSiteRecord> &
153   getValueSitesForKind(uint32_t ValueKind) const {
154     switch (ValueKind) {
155     case IPVK_IndirectCallTarget:
156       return IndirectCallSites;
157     }
158     llvm_unreachable("Unknown value kind!");
159   }
160
161   std::vector<InstrProfValueSiteRecord> &
162   getValueSitesForKind(uint32_t ValueKind) {
163     return const_cast<std::vector<InstrProfValueSiteRecord> &>(
164         const_cast<const InstrProfRecord *>(this)
165             ->getValueSitesForKind(ValueKind));
166   }
167 };
168
169 namespace IndexedInstrProf {
170 enum class HashT : uint32_t {
171   MD5,
172
173   Last = MD5
174 };
175
176 static inline uint64_t MD5Hash(StringRef Str) {
177   MD5 Hash;
178   Hash.update(Str);
179   llvm::MD5::MD5Result Result;
180   Hash.final(Result);
181   // Return the least significant 8 bytes. Our MD5 implementation returns the
182   // result in little endian, so we may need to swap bytes.
183   using namespace llvm::support;
184   return endian::read<uint64_t, little, unaligned>(Result);
185 }
186
187 static inline uint64_t ComputeHash(HashT Type, StringRef K) {
188   switch (Type) {
189     case HashT::MD5:
190       return IndexedInstrProf::MD5Hash(K);
191   }
192   llvm_unreachable("Unhandled hash type");
193 }
194
195 const uint64_t Magic = 0x8169666f72706cff;  // "\xfflprofi\x81"
196 const uint64_t Version = 3;
197 const HashT HashType = HashT::MD5;
198
199 struct Header {
200   uint64_t Magic;
201   uint64_t Version;
202   uint64_t MaxFunctionCount;
203   uint64_t HashType;
204   uint64_t HashOffset;
205 };
206
207 }  // end namespace IndexedInstrProf
208
209 namespace RawInstrProf {
210
211 const uint64_t Version = 1;
212
213 // Magic number to detect file format and endianness.
214 // Use 255 at one end, since no UTF-8 file can use that character.  Avoid 0,
215 // so that utilities, like strings, don't grab it as a string.  129 is also
216 // invalid UTF-8, and high enough to be interesting.
217 // Use "lprofr" in the centre to stand for "LLVM Profile Raw", or "lprofR"
218 // for 32-bit platforms.
219 // The magic and version need to be kept in sync with
220 // projects/compiler-rt/lib/profile/InstrProfiling.c
221
222 template <class IntPtrT>
223 inline uint64_t getMagic();
224 template <>
225 inline uint64_t getMagic<uint64_t>() {
226   return uint64_t(255) << 56 | uint64_t('l') << 48 | uint64_t('p') << 40 |
227          uint64_t('r') << 32 | uint64_t('o') << 24 | uint64_t('f') << 16 |
228          uint64_t('r') << 8 | uint64_t(129);
229 }
230
231 template <>
232 inline uint64_t getMagic<uint32_t>() {
233   return uint64_t(255) << 56 | uint64_t('l') << 48 | uint64_t('p') << 40 |
234          uint64_t('r') << 32 | uint64_t('o') << 24 | uint64_t('f') << 16 |
235          uint64_t('R') << 8 | uint64_t(129);
236 }
237
238 // The definition should match the structure defined in
239 // compiler-rt/lib/profile/InstrProfiling.h.
240 // It should also match the synthesized type in
241 // Transforms/Instrumentation/InstrProfiling.cpp:getOrCreateRegionCounters.
242
243 template <class IntPtrT>
244 struct ProfileData {
245   const uint32_t NameSize;
246   const uint32_t NumCounters;
247   const uint64_t FuncHash;
248   const IntPtrT NamePtr;
249   const IntPtrT CounterPtr;
250 };
251
252 // The definition should match the header referenced in
253 // compiler-rt/lib/profile/InstrProfilingFile.c  and
254 // InstrProfilingBuffer.c.
255
256 struct Header {
257   const uint64_t Magic;
258   const uint64_t Version;
259   const uint64_t DataSize;
260   const uint64_t CountersSize;
261   const uint64_t NamesSize;
262   const uint64_t CountersDelta;
263   const uint64_t NamesDelta;
264 };
265
266 }  // end namespace RawInstrProf
267
268 } // end namespace llvm
269
270 namespace std {
271 template <>
272 struct is_error_code_enum<llvm::instrprof_error> : std::true_type {};
273 }
274
275 #endif // LLVM_PROFILEDATA_INSTRPROF_H_