LLVM  10.0.0svn
InstrProfWriter.cpp
Go to the documentation of this file.
1 //===- InstrProfWriter.cpp - Instrumented profiling writer ----------------===//
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 support for writing profiling data for clang's
10 // instrumentation based PGO and coverage.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/IR/ProfileSummary.h"
20 #include "llvm/Support/Endian.h"
22 #include "llvm/Support/Error.h"
26 #include <algorithm>
27 #include <cstdint>
28 #include <memory>
29 #include <string>
30 #include <tuple>
31 #include <utility>
32 #include <vector>
33 
34 using namespace llvm;
35 
36 // A struct to define how the data stream should be patched. For Indexed
37 // profiling, only uint64_t data type is needed.
38 struct PatchItem {
39  uint64_t Pos; // Where to patch.
40  uint64_t *D; // Pointer to an array of source data.
41  int N; // Number of elements in \c D array.
42 };
43 
44 namespace llvm {
45 
46 // A wrapper class to abstract writer stream with support of bytes
47 // back patching.
48 class ProfOStream {
49 public:
51  : IsFDOStream(true), OS(FD), LE(FD, support::little) {}
53  : IsFDOStream(false), OS(STR), LE(STR, support::little) {}
54 
55  uint64_t tell() { return OS.tell(); }
56  void write(uint64_t V) { LE.write<uint64_t>(V); }
57 
58  // \c patch can only be called when all data is written and flushed.
59  // For raw_string_ostream, the patch is done on the target string
60  // directly and it won't be reflected in the stream's internal buffer.
61  void patch(PatchItem *P, int NItems) {
62  using namespace support;
63 
64  if (IsFDOStream) {
65  raw_fd_ostream &FDOStream = static_cast<raw_fd_ostream &>(OS);
66  for (int K = 0; K < NItems; K++) {
67  FDOStream.seek(P[K].Pos);
68  for (int I = 0; I < P[K].N; I++)
69  write(P[K].D[I]);
70  }
71  } else {
72  raw_string_ostream &SOStream = static_cast<raw_string_ostream &>(OS);
73  std::string &Data = SOStream.str(); // with flush
74  for (int K = 0; K < NItems; K++) {
75  for (int I = 0; I < P[K].N; I++) {
76  uint64_t Bytes = endian::byte_swap<uint64_t, little>(P[K].D[I]);
77  Data.replace(P[K].Pos + I * sizeof(uint64_t), sizeof(uint64_t),
78  (const char *)&Bytes, sizeof(uint64_t));
79  }
80  }
81  }
82  }
83 
84  // If \c OS is an instance of \c raw_fd_ostream, this field will be
85  // true. Otherwise, \c OS will be an raw_string_ostream.
89 };
90 
92 public:
95 
98 
99  using hash_value_type = uint64_t;
100  using offset_type = uint64_t;
101 
102  support::endianness ValueProfDataEndianness = support::little;
105 
106  InstrProfRecordWriterTrait() = default;
107 
110  }
111 
112  static std::pair<offset_type, offset_type>
114  using namespace support;
115 
116  endian::Writer LE(Out, little);
117 
118  offset_type N = K.size();
119  LE.write<offset_type>(N);
120 
121  offset_type M = 0;
122  for (const auto &ProfileData : *V) {
123  const InstrProfRecord &ProfRecord = ProfileData.second;
124  M += sizeof(uint64_t); // The function hash
125  M += sizeof(uint64_t); // The size of the Counts vector
126  M += ProfRecord.Counts.size() * sizeof(uint64_t);
127 
128  // Value data
129  M += ValueProfData::getSize(ProfileData.second);
130  }
131  LE.write<offset_type>(M);
132 
133  return std::make_pair(N, M);
134  }
135 
137  Out.write(K.data(), N);
138  }
139 
141  using namespace support;
142 
143  endian::Writer LE(Out, little);
144  for (const auto &ProfileData : *V) {
145  const InstrProfRecord &ProfRecord = ProfileData.second;
146  if (NamedInstrProfRecord::hasCSFlagInHash(ProfileData.first))
147  CSSummaryBuilder->addRecord(ProfRecord);
148  else
149  SummaryBuilder->addRecord(ProfRecord);
150 
151  LE.write<uint64_t>(ProfileData.first); // Function hash
152  LE.write<uint64_t>(ProfRecord.Counts.size());
153  for (uint64_t I : ProfRecord.Counts)
154  LE.write<uint64_t>(I);
155 
156  // Write value data
157  std::unique_ptr<ValueProfData> VDataPtr =
158  ValueProfData::serializeFrom(ProfileData.second);
159  uint32_t S = VDataPtr->getSize();
160  VDataPtr->swapBytesFromHost(ValueProfDataEndianness);
161  Out.write((const char *)VDataPtr.get(), S);
162  }
163  }
164 };
165 
166 } // end namespace llvm
167 
169  : Sparse(Sparse), InfoObj(new InstrProfRecordWriterTrait()) {}
170 
172 
173 // Internal interface for testing purpose only.
177 }
178 
180  this->Sparse = Sparse;
181 }
182 
184  function_ref<void(Error)> Warn) {
185  auto Name = I.Name;
186  auto Hash = I.Hash;
187  addRecord(Name, Hash, std::move(I), Weight, Warn);
188 }
189 
191  OverlapStats &Overlap,
192  OverlapStats &FuncLevelOverlap,
193  const OverlapFuncFilters &FuncFilter) {
194  auto Name = Other.Name;
195  auto Hash = Other.Hash;
196  Other.accumulateCounts(FuncLevelOverlap.Test);
197  if (FunctionData.find(Name) == FunctionData.end()) {
198  Overlap.addOneUnique(FuncLevelOverlap.Test);
199  return;
200  }
201  if (FuncLevelOverlap.Test.CountSum < 1.0f) {
202  Overlap.Overlap.NumEntries += 1;
203  return;
204  }
205  auto &ProfileDataMap = FunctionData[Name];
206  bool NewFunc;
208  std::tie(Where, NewFunc) =
209  ProfileDataMap.insert(std::make_pair(Hash, InstrProfRecord()));
210  if (NewFunc) {
211  Overlap.addOneMismatch(FuncLevelOverlap.Test);
212  return;
213  }
214  InstrProfRecord &Dest = Where->second;
215 
216  uint64_t ValueCutoff = FuncFilter.ValueCutoff;
217  if (!FuncFilter.NameFilter.empty() &&
218  Name.find(FuncFilter.NameFilter) != Name.npos)
219  ValueCutoff = 0;
220 
221  Dest.overlap(Other, Overlap, FuncLevelOverlap, ValueCutoff);
222 }
223 
224 void InstrProfWriter::addRecord(StringRef Name, uint64_t Hash,
225  InstrProfRecord &&I, uint64_t Weight,
226  function_ref<void(Error)> Warn) {
227  auto &ProfileDataMap = FunctionData[Name];
228 
229  bool NewFunc;
231  std::tie(Where, NewFunc) =
232  ProfileDataMap.insert(std::make_pair(Hash, InstrProfRecord()));
233  InstrProfRecord &Dest = Where->second;
234 
235  auto MapWarn = [&](instrprof_error E) {
236  Warn(make_error<InstrProfError>(E));
237  };
238 
239  if (NewFunc) {
240  // We've never seen a function with this name and hash, add it.
241  Dest = std::move(I);
242  if (Weight > 1)
243  Dest.scale(Weight, MapWarn);
244  } else {
245  // We're updating a function we've seen before.
246  Dest.merge(I, Weight, MapWarn);
247  }
248 
249  Dest.sortValueData();
250 }
251 
253  function_ref<void(Error)> Warn) {
254  for (auto &I : IPW.FunctionData)
255  for (auto &Func : I.getValue())
256  addRecord(I.getKey(), Func.first, std::move(Func.second), 1, Warn);
257 }
258 
259 bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) {
260  if (!Sparse)
261  return true;
262  for (const auto &Func : PD) {
263  const InstrProfRecord &IPR = Func.second;
264  if (llvm::any_of(IPR.Counts, [](uint64_t Count) { return Count > 0; }))
265  return true;
266  }
267  return false;
268 }
269 
270 static void setSummary(IndexedInstrProf::Summary *TheSummary,
271  ProfileSummary &PS) {
272  using namespace IndexedInstrProf;
273 
274  std::vector<ProfileSummaryEntry> &Res = PS.getDetailedSummary();
275  TheSummary->NumSummaryFields = Summary::NumKinds;
276  TheSummary->NumCutoffEntries = Res.size();
277  TheSummary->set(Summary::MaxFunctionCount, PS.getMaxFunctionCount());
278  TheSummary->set(Summary::MaxBlockCount, PS.getMaxCount());
279  TheSummary->set(Summary::MaxInternalBlockCount, PS.getMaxInternalCount());
280  TheSummary->set(Summary::TotalBlockCount, PS.getTotalCount());
281  TheSummary->set(Summary::TotalNumBlocks, PS.getNumCounts());
282  TheSummary->set(Summary::TotalNumFunctions, PS.getNumFunctions());
283  for (unsigned I = 0; I < Res.size(); I++)
284  TheSummary->setEntry(I, Res[I]);
285 }
286 
287 void InstrProfWriter::writeImpl(ProfOStream &OS) {
288  using namespace IndexedInstrProf;
289 
291 
293  InfoObj->SummaryBuilder = &ISB;
295  InfoObj->CSSummaryBuilder = &CSISB;
296 
297  // Populate the hash table generator.
298  for (const auto &I : FunctionData)
299  if (shouldEncodeData(I.getValue()))
300  Generator.insert(I.getKey(), &I.getValue());
301  // Write the header.
305  if (ProfileKind == PF_IRLevel)
306  Header.Version |= VARIANT_MASK_IR_PROF;
307  if (ProfileKind == PF_IRLevelWithCS) {
308  Header.Version |= VARIANT_MASK_IR_PROF;
309  Header.Version |= VARIANT_MASK_CSIR_PROF;
310  }
311  Header.Unused = 0;
312  Header.HashType = static_cast<uint64_t>(IndexedInstrProf::HashType);
313  Header.HashOffset = 0;
314  int N = sizeof(IndexedInstrProf::Header) / sizeof(uint64_t);
315 
316  // Only write out all the fields except 'HashOffset'. We need
317  // to remember the offset of that field to allow back patching
318  // later.
319  for (int I = 0; I < N - 1; I++)
320  OS.write(reinterpret_cast<uint64_t *>(&Header)[I]);
321 
322  // Save the location of Header.HashOffset field in \c OS.
323  uint64_t HashTableStartFieldOffset = OS.tell();
324  // Reserve the space for HashOffset field.
325  OS.write(0);
326 
327  // Reserve space to write profile summary data.
329  uint32_t SummarySize = Summary::getSize(Summary::NumKinds, NumEntries);
330  // Remember the summary offset.
331  uint64_t SummaryOffset = OS.tell();
332  for (unsigned I = 0; I < SummarySize / sizeof(uint64_t); I++)
333  OS.write(0);
334  uint64_t CSSummaryOffset = 0;
335  uint64_t CSSummarySize = 0;
336  if (ProfileKind == PF_IRLevelWithCS) {
337  CSSummaryOffset = OS.tell();
338  CSSummarySize = SummarySize / sizeof(uint64_t);
339  for (unsigned I = 0; I < CSSummarySize; I++)
340  OS.write(0);
341  }
342 
343  // Write the hash table.
344  uint64_t HashTableStart = Generator.Emit(OS.OS, *InfoObj);
345 
346  // Allocate space for data to be serialized out.
347  std::unique_ptr<IndexedInstrProf::Summary> TheSummary =
348  IndexedInstrProf::allocSummary(SummarySize);
349  // Compute the Summary and copy the data to the data
350  // structure to be serialized out (to disk or buffer).
351  std::unique_ptr<ProfileSummary> PS = ISB.getSummary();
352  setSummary(TheSummary.get(), *PS);
353  InfoObj->SummaryBuilder = nullptr;
354 
355  // For Context Sensitive summary.
356  std::unique_ptr<IndexedInstrProf::Summary> TheCSSummary = nullptr;
357  if (ProfileKind == PF_IRLevelWithCS) {
358  TheCSSummary = IndexedInstrProf::allocSummary(SummarySize);
359  std::unique_ptr<ProfileSummary> CSPS = CSISB.getSummary();
360  setSummary(TheCSSummary.get(), *CSPS);
361  }
362  InfoObj->CSSummaryBuilder = nullptr;
363 
364  // Now do the final patch:
365  PatchItem PatchItems[] = {
366  // Patch the Header.HashOffset field.
367  {HashTableStartFieldOffset, &HashTableStart, 1},
368  // Patch the summary data.
369  {SummaryOffset, reinterpret_cast<uint64_t *>(TheSummary.get()),
370  (int)(SummarySize / sizeof(uint64_t))},
371  {CSSummaryOffset, reinterpret_cast<uint64_t *>(TheCSSummary.get()),
372  (int)CSSummarySize}};
373 
374  OS.patch(PatchItems, sizeof(PatchItems) / sizeof(*PatchItems));
375 }
376 
378  // Write the hash table.
379  ProfOStream POS(OS);
380  writeImpl(POS);
381 }
382 
383 std::unique_ptr<MemoryBuffer> InstrProfWriter::writeBuffer() {
384  std::string Data;
385  raw_string_ostream OS(Data);
386  ProfOStream POS(OS);
387  // Write the hash table.
388  writeImpl(POS);
389  // Return this in an aligned memory buffer.
390  return MemoryBuffer::getMemBufferCopy(Data);
391 }
392 
393 static const char *ValueProfKindStr[] = {
394 #define VALUE_PROF_KIND(Enumerator, Value, Descr) #Enumerator,
396 };
397 
399  const InstrProfRecord &Func,
400  InstrProfSymtab &Symtab,
401  raw_fd_ostream &OS) {
402  OS << Name << "\n";
403  OS << "# Func Hash:\n" << Hash << "\n";
404  OS << "# Num Counters:\n" << Func.Counts.size() << "\n";
405  OS << "# Counter Values:\n";
406  for (uint64_t Count : Func.Counts)
407  OS << Count << "\n";
408 
409  uint32_t NumValueKinds = Func.getNumValueKinds();
410  if (!NumValueKinds) {
411  OS << "\n";
412  return;
413  }
414 
415  OS << "# Num Value Kinds:\n" << Func.getNumValueKinds() << "\n";
416  for (uint32_t VK = 0; VK < IPVK_Last + 1; VK++) {
417  uint32_t NS = Func.getNumValueSites(VK);
418  if (!NS)
419  continue;
420  OS << "# ValueKind = " << ValueProfKindStr[VK] << ":\n" << VK << "\n";
421  OS << "# NumValueSites:\n" << NS << "\n";
422  for (uint32_t S = 0; S < NS; S++) {
423  uint32_t ND = Func.getNumValueDataForSite(VK, S);
424  OS << ND << "\n";
425  std::unique_ptr<InstrProfValueData[]> VD = Func.getValueForSite(VK, S);
426  for (uint32_t I = 0; I < ND; I++) {
427  if (VK == IPVK_IndirectCallTarget)
428  OS << Symtab.getFuncNameOrExternalSymbol(VD[I].Value) << ":"
429  << VD[I].Count << "\n";
430  else
431  OS << VD[I].Value << ":" << VD[I].Count << "\n";
432  }
433  }
434  }
435 
436  OS << "\n";
437 }
438 
440  if (ProfileKind == PF_IRLevel)
441  OS << "# IR level Instrumentation Flag\n:ir\n";
442  else if (ProfileKind == PF_IRLevelWithCS)
443  OS << "# CSIR level Instrumentation Flag\n:csir\n";
444  InstrProfSymtab Symtab;
445 
447  using RecordType = std::pair<StringRef, FuncPair>;
448  SmallVector<RecordType, 4> OrderedFuncData;
449 
450  for (const auto &I : FunctionData) {
451  if (shouldEncodeData(I.getValue())) {
452  if (Error E = Symtab.addFuncName(I.getKey()))
453  return E;
454  for (const auto &Func : I.getValue())
455  OrderedFuncData.push_back(std::make_pair(I.getKey(), Func));
456  }
457  }
458 
459  llvm::sort(OrderedFuncData, [](const RecordType &A, const RecordType &B) {
460  return std::tie(A.first, A.second.first) <
461  std::tie(B.first, B.second.first);
462  });
463 
464  for (const auto &record : OrderedFuncData) {
465  const StringRef &Name = record.first;
466  const FuncPair &Func = record.second;
467  writeRecordInText(Name, Func.first, Func.second, Symtab, OS);
468  }
469 
470  return Error::success();
471 }
void setValueProfDataEndianness(support::endianness Endianness)
const InstrProfWriter::ProfilingData *const data_type
static const char * ValueProfKindStr[]
void overlap(InstrProfRecord &Other, OverlapStats &Overlap, OverlapStats &FuncLevelOverlap, uint64_t ValueCutoff)
Compute the overlap b/w this IntrprofRecord and Other.
Definition: InstrProf.cpp:550
void addOneMismatch(const CountSumOrPercent &MismatchFunc)
Definition: InstrProf.cpp:1192
A symbol table used for function PGO name look-up with keys (such as pointers, md5hash values) to the...
Definition: InstrProf.h:406
void merge(InstrProfRecord &Other, uint64_t Weight, function_ref< void(instrprof_error)> Warn)
Merge the counts in Other into this one.
Definition: InstrProf.cpp:655
void sortValueData()
Sort value profile data (per site) by count.
Definition: InstrProf.h:755
This class represents lattice values for constants.
Definition: AllocatorList.h:23
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
ProfOStream(raw_string_ostream &STR)
Defines facilities for reading and writing on-disk hash tables.
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:880
void setEntry(uint32_t I, const ProfileSummaryEntry &E)
Definition: InstrProf.h:1069
uint64_t seek(uint64_t off)
Flushes the stream and repositions the underlying file descriptor position to the offset specified fr...
InstrProfWriter(bool Sparse=false)
Optional< std::vector< StOtherPiece > > Other
Definition: ELFYAML.cpp:953
const std::string NameFilter
Definition: InstrProf.h:650
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:104
std::unique_ptr< Summary > allocSummary(uint32_t TotalSize)
Definition: InstrProf.h:1077
static const ArrayRef< uint32_t > DefaultCutoffs
A vector of useful cutoff values for detailed summary.
Definition: ProfileCommon.h:64
constexpr support::endianness Endianness
The endianness of all multi-byte encoded values in MessagePack.
Definition: MsgPack.h:24
block Block Frequency true
uint64_t getMaxInternalCount()
void addRecord(const InstrProfRecord &)
uint32_t getNumValueSites(uint32_t ValueKind) const
Return the number of instrumented sites for ValueKind.
Definition: InstrProf.h:876
static void setSummary(IndexedInstrProf::Summary *TheSummary, ProfileSummary &PS)
const uint64_t Magic
Definition: InstrProf.h:956
void EmitKey(raw_ostream &Out, key_type_ref K, offset_type N)
const InstrProfWriter::ProfilingData *const data_type_ref
void addRecord(NamedInstrProfRecord &&I, uint64_t Weight, function_ref< void(Error)> Warn)
Add function counts for the given function.
const HashT HashType
Definition: InstrProf.h:982
void scale(uint64_t Weight, function_ref< void(instrprof_error)> Warn)
Scale up profile counts (including value profile data) by Weight.
Definition: InstrProf.cpp:683
static std::pair< offset_type, offset_type > EmitKeyDataLength(raw_ostream &Out, key_type_ref K, data_type_ref V)
uint64_t getMaxFunctionCount()
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:144
SummaryEntryVector & getDetailedSummary()
void mergeRecordsFromWriter(InstrProfWriter &&IPW, function_ref< void(Error)> Warn)
Merge existing function counts from the given writer.
#define P(N)
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
void setOutputSparse(bool Sparse)
static hash_value_type ComputeHash(key_type_ref K)
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:148
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
uint64_t Pos
InstrProfSummaryBuilder * CSSummaryBuilder
uint32_t getNumValueKinds() const
Return the number of value profile kinds with non-zero number of profile sites.
Definition: InstrProf.h:862
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:1172
static bool hasCSFlagInHash(uint64_t FuncHash)
Definition: InstrProf.h:854
uint64_t ComputeHash(StringRef K)
Definition: InstrProf.h:984
static void write(bool isBE, void *P, T V)
std::string & str()
Flushes the stream contents to the target string and returns the string&#39;s reference.
Definition: raw_ostream.h:519
raw_ostream & write(unsigned char C)
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1095
void addOneUnique(const CountSumOrPercent &UniqueFunc)
Definition: InstrProf.cpp:1202
CountSumOrPercent Test
Definition: InstrProf.h:610
static ErrorSuccess success()
Create a success value.
Definition: Error.h:326
void write(uint64_t V)
offset_type Emit(raw_ostream &Out)
Emit the table to Out, which must not be at offset 0.
uint64_t getTotalCount()
std::unique_ptr< ProfileSummary > getSummary()
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:837
support::endianness ValueProfDataEndianness
support::endian::Writer LE
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static std::unique_ptr< MemoryBuffer > getMemBufferCopy(StringRef InputData, const Twine &BufferName="")
Open the specified memory range as a MemoryBuffer, copying the contents and taking ownership of it...
CountSumOrPercent Overlap
Definition: InstrProf.h:612
Generates an on disk hash table.
std::vector< uint64_t > Counts
Definition: InstrProf.h:686
static void writeRecordInText(StringRef Name, uint64_t Hash, const InstrProfRecord &Counters, InstrProfSymtab &Symtab, raw_fd_ostream &OS)
Write Record in text format to OS.
Adapter to write values to a stream in a particular byte order.
Definition: EndianStream.h:51
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:384
uint32_t getNumFunctions()
Profiling information for a single function.
Definition: InstrProf.h:685
instrprof_error
Definition: InstrProf.h:275
void EmitData(raw_ostream &Out, key_type_ref, data_type_ref V, offset_type)
Error addFuncName(StringRef FuncName)
Update the symtab by adding FuncName to the table.
Definition: InstrProf.h:467
#define I(x, y, z)
Definition: MD5.cpp:58
#define N
void patch(PatchItem *P, int NItems)
void overlapRecord(NamedInstrProfRecord &&Other, OverlapStats &Overlap, OverlapStats &FuncLevelOverlap, const OverlapFuncFilters &FuncFilter)
InstrProfSummaryBuilder * SummaryBuilder
uint64_t * D
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:136
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:503
void write(raw_fd_ostream &OS)
Write the profile to OS.
LLVM Value Representation.
Definition: Value.h:74
Error writeText(raw_fd_ostream &OS)
Write the profile in text format to OS.
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
ProfOStream(raw_fd_ostream &FD)
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
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:886
StringRef getFuncNameOrExternalSymbol(uint64_t FuncMD5Hash)
Just like getFuncName, except that it will return a non-empty StringRef if the function is external t...
Definition: InstrProf.h:550
void set(SummaryFieldKind K, uint64_t V)
Definition: InstrProf.h:1063
std::unique_ptr< MemoryBuffer > writeBuffer()
Write the profile, returning the raw data. For testing.