LLVM 19.0.0git
InstrProfReader.h
Go to the documentation of this file.
1//===- InstrProfReader.h - Instrumented profiling readers -------*- 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 support for reading profiling data for instrumentation
10// based PGO and coverage.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_PROFILEDATA_INSTRPROFREADER_H
15#define LLVM_PROFILEDATA_INSTRPROFREADER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/StringRef.h"
20#include "llvm/Object/BuildID.h"
24#include "llvm/Support/Endian.h"
25#include "llvm/Support/Error.h"
31#include <algorithm>
32#include <cassert>
33#include <cstddef>
34#include <cstdint>
35#include <iterator>
36#include <memory>
37#include <utility>
38#include <vector>
39
40namespace llvm {
41
42class InstrProfReader;
43
44namespace vfs {
45class FileSystem;
46} // namespace vfs
47
48/// A file format agnostic iterator over profiling data.
49template <class record_type = NamedInstrProfRecord,
50 class reader_type = InstrProfReader>
52public:
53 using iterator_category = std::input_iterator_tag;
54 using value_type = record_type;
55 using difference_type = std::ptrdiff_t;
58
59private:
60 reader_type *Reader = nullptr;
62
63 void increment() {
64 if (Error E = Reader->readNextRecord(Record)) {
65 // Handle errors in the reader.
66 InstrProfError::take(std::move(E));
67 *this = InstrProfIterator();
68 }
69 }
70
71public:
72 InstrProfIterator() = default;
73 InstrProfIterator(reader_type *Reader) : Reader(Reader) { increment(); }
74
76 increment();
77 return *this;
78 }
79 bool operator==(const InstrProfIterator &RHS) const {
80 return Reader == RHS.Reader;
81 }
82 bool operator!=(const InstrProfIterator &RHS) const {
83 return Reader != RHS.Reader;
84 }
87};
88
89/// Base class and interface for reading profiling data of any known instrprof
90/// format. Provides an iterator over NamedInstrProfRecords.
93 std::string LastErrorMsg;
94
95public:
96 InstrProfReader() = default;
97 virtual ~InstrProfReader() = default;
98
99 /// Read the header. Required before reading first record.
100 virtual Error readHeader() = 0;
101
102 /// Read a single record.
104
105 /// Read a list of binary ids.
106 virtual Error readBinaryIds(std::vector<llvm::object::BuildID> &BinaryIds) {
107 return success();
108 }
109
110 /// Print binary ids.
111 virtual Error printBinaryIds(raw_ostream &OS) { return success(); };
112
113 /// Iterator over profile data.
116
117 /// Return the profile version.
118 virtual uint64_t getVersion() const = 0;
119
120 virtual bool isIRLevelProfile() const = 0;
121
122 virtual bool hasCSIRLevelProfile() const = 0;
123
124 virtual bool instrEntryBBEnabled() const = 0;
125
126 /// Return true if the profile has single byte counters representing coverage.
127 virtual bool hasSingleByteCoverage() const = 0;
128
129 /// Return true if the profile only instruments function entries.
130 virtual bool functionEntryOnly() const = 0;
131
132 /// Return true if profile includes a memory profile.
133 virtual bool hasMemoryProfile() const = 0;
134
135 /// Return true if this has a temporal profile.
136 virtual bool hasTemporalProfile() const = 0;
137
138 /// Returns a BitsetEnum describing the attributes of the profile. To check
139 /// individual attributes prefer using the helpers above.
140 virtual InstrProfKind getProfileKind() const = 0;
141
142 /// Return the PGO symtab. There are three different readers:
143 /// Raw, Text, and Indexed profile readers. The first two types
144 /// of readers are used only by llvm-profdata tool, while the indexed
145 /// profile reader is also used by llvm-cov tool and the compiler (
146 /// backend or frontend). Since creating PGO symtab can create
147 /// significant runtime and memory overhead (as it touches data
148 /// for the whole program), InstrProfSymtab for the indexed profile
149 /// reader should be created on demand and it is recommended to be
150 /// only used for dumping purpose with llvm-proftool, not with the
151 /// compiler.
153
154 /// Compute the sum of counts and return in Sum.
155 void accumulateCounts(CountSumOrPercent &Sum, bool IsCS);
156
157protected:
158 std::unique_ptr<InstrProfSymtab> Symtab;
159 /// A list of temporal profile traces.
161 /// The total number of temporal profile traces seen.
163
164 /// Set the current error and return same.
165 Error error(instrprof_error Err, const std::string &ErrMsg = "") {
166 LastError = Err;
167 LastErrorMsg = ErrMsg;
168 if (Err == instrprof_error::success)
169 return Error::success();
170 return make_error<InstrProfError>(Err, ErrMsg);
171 }
172
174 handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
175 LastError = IPE.get();
176 LastErrorMsg = IPE.getMessage();
177 });
178 return make_error<InstrProfError>(LastError, LastErrorMsg);
179 }
180
181 /// Clear the current error and return a successful one.
183
184public:
185 /// Return true if the reader has finished reading the profile data.
186 bool isEOF() { return LastError == instrprof_error::eof; }
187
188 /// Return true if the reader encountered an error reading profiling data.
189 bool hasError() { return LastError != instrprof_error::success && !isEOF(); }
190
191 /// Get the current error.
193 if (hasError())
194 return make_error<InstrProfError>(LastError, LastErrorMsg);
195 return Error::success();
196 }
197
198 /// Factory method to create an appropriately typed reader for the given
199 /// instrprof file.
201 create(const Twine &Path, vfs::FileSystem &FS,
202 const InstrProfCorrelator *Correlator = nullptr,
203 std::function<void(Error)> Warn = nullptr);
204
206 create(std::unique_ptr<MemoryBuffer> Buffer,
207 const InstrProfCorrelator *Correlator = nullptr,
208 std::function<void(Error)> Warn = nullptr);
209
210 /// \param Weight for raw profiles use this as the temporal profile trace
211 /// weight
212 /// \returns a list of temporal profile traces.
214 getTemporalProfTraces(std::optional<uint64_t> Weight = {}) {
215 // For non-raw profiles we ignore the input weight and instead use the
216 // weights already in the traces.
217 return TemporalProfTraces;
218 }
219 /// \returns the total number of temporal profile traces seen.
222 }
223};
224
225/// Reader for the simple text based instrprof format.
226///
227/// This format is a simple text format that's suitable for test data. Records
228/// are separated by one or more blank lines, and record fields are separated by
229/// new lines.
230///
231/// Each record consists of a function name, a function hash, a number of
232/// counters, and then each counter value, in that order.
234private:
235 /// The profile data file contents.
236 std::unique_ptr<MemoryBuffer> DataBuffer;
237 /// Iterator over the profile data.
238 line_iterator Line;
239 /// The attributes of the current profile.
241
242 Error readValueProfileData(InstrProfRecord &Record);
243
244 Error readTemporalProfTraceData();
245
246public:
247 TextInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer_)
248 : DataBuffer(std::move(DataBuffer_)), Line(*DataBuffer, true, '#') {}
251
252 /// Return true if the given buffer is in text instrprof format.
253 static bool hasFormat(const MemoryBuffer &Buffer);
254
255 // Text format does not have version, so return 0.
256 uint64_t getVersion() const override { return 0; }
257
258 bool isIRLevelProfile() const override {
259 return static_cast<bool>(ProfileKind & InstrProfKind::IRInstrumentation);
260 }
261
262 bool hasCSIRLevelProfile() const override {
263 return static_cast<bool>(ProfileKind & InstrProfKind::ContextSensitive);
264 }
265
266 bool instrEntryBBEnabled() const override {
267 return static_cast<bool>(ProfileKind &
269 }
270
271 bool hasSingleByteCoverage() const override {
272 return static_cast<bool>(ProfileKind & InstrProfKind::SingleByteCoverage);
273 }
274
275 bool functionEntryOnly() const override {
276 return static_cast<bool>(ProfileKind & InstrProfKind::FunctionEntryOnly);
277 }
278
279 bool hasMemoryProfile() const override {
280 // TODO: Add support for text format memory profiles.
281 return false;
282 }
283
284 bool hasTemporalProfile() const override {
285 return static_cast<bool>(ProfileKind & InstrProfKind::TemporalProfile);
286 }
287
288 InstrProfKind getProfileKind() const override { return ProfileKind; }
289
290 /// Read the header.
291 Error readHeader() override;
292
293 /// Read a single record.
295
297 assert(Symtab);
298 return *Symtab;
299 }
300};
301
302/// Reader for the raw instrprof binary format from runtime.
303///
304/// This format is a raw memory dump of the instrumentation-based profiling data
305/// from the runtime. It has no index.
306///
307/// Templated on the unsigned type whose size matches pointers on the platform
308/// that wrote the profile.
309template <class IntPtrT>
311private:
312 /// The profile data file contents.
313 std::unique_ptr<MemoryBuffer> DataBuffer;
314 /// If available, this hold the ProfileData array used to correlate raw
315 /// instrumentation data to their functions.
316 const InstrProfCorrelatorImpl<IntPtrT> *Correlator;
317 /// A list of timestamps paired with a function name reference.
318 std::vector<std::pair<uint64_t, uint64_t>> TemporalProfTimestamps;
319 bool ShouldSwapBytes;
320 // The value of the version field of the raw profile data header. The lower 32
321 // bits specifies the format version and the most significant 32 bits specify
322 // the variant types of the profile.
323 uint64_t Version;
324 uint64_t CountersDelta;
325 uint64_t BitmapDelta;
326 uint64_t NamesDelta;
329 const RawInstrProf::VTableProfileData<IntPtrT> *VTableBegin = nullptr;
330 const RawInstrProf::VTableProfileData<IntPtrT> *VTableEnd = nullptr;
331 const char *CountersStart;
332 const char *CountersEnd;
333 const char *BitmapStart;
334 const char *BitmapEnd;
335 const char *NamesStart;
336 const char *NamesEnd;
337 const char *VNamesStart = nullptr;
338 const char *VNamesEnd = nullptr;
339 // After value profile is all read, this pointer points to
340 // the header of next profile data (if exists)
341 const uint8_t *ValueDataStart;
342 uint32_t ValueKindLast;
343 uint32_t CurValueDataSize;
344 std::vector<llvm::object::BuildID> BinaryIds;
345
346 std::function<void(Error)> Warn;
347
348 /// Maxium counter value 2^56.
349 static const uint64_t MaxCounterValue = (1ULL << 56);
350
351public:
352 RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer,
353 const InstrProfCorrelator *Correlator,
354 std::function<void(Error)> Warn)
355 : DataBuffer(std::move(DataBuffer)),
357 Correlator)),
358 Warn(Warn) {}
361
362 static bool hasFormat(const MemoryBuffer &DataBuffer);
363 Error readHeader() override;
365 Error readBinaryIds(std::vector<llvm::object::BuildID> &BinaryIds) override;
367
368 uint64_t getVersion() const override { return Version; }
369
370 bool isIRLevelProfile() const override {
371 return (Version & VARIANT_MASK_IR_PROF) != 0;
372 }
373
374 bool hasCSIRLevelProfile() const override {
375 return (Version & VARIANT_MASK_CSIR_PROF) != 0;
376 }
377
378 bool instrEntryBBEnabled() const override {
379 return (Version & VARIANT_MASK_INSTR_ENTRY) != 0;
380 }
381
382 bool hasSingleByteCoverage() const override {
383 return (Version & VARIANT_MASK_BYTE_COVERAGE) != 0;
384 }
385
386 bool functionEntryOnly() const override {
387 return (Version & VARIANT_MASK_FUNCTION_ENTRY_ONLY) != 0;
388 }
389
390 bool hasMemoryProfile() const override {
391 // Memory profiles have a separate raw format, so this should never be set.
392 assert(!(Version & VARIANT_MASK_MEMPROF));
393 return false;
394 }
395
396 bool hasTemporalProfile() const override {
397 return (Version & VARIANT_MASK_TEMPORAL_PROF) != 0;
398 }
399
400 /// Returns a BitsetEnum describing the attributes of the raw instr profile.
401 InstrProfKind getProfileKind() const override;
402
404 assert(Symtab.get());
405 return *Symtab.get();
406 }
407
409 getTemporalProfTraces(std::optional<uint64_t> Weight = {}) override;
410
411private:
412 Error createSymtab(InstrProfSymtab &Symtab);
413 Error readNextHeader(const char *CurrentPos);
414 Error readHeader(const RawInstrProf::Header &Header);
415
416 template <class IntT> IntT swap(IntT Int) const {
417 return ShouldSwapBytes ? llvm::byteswap(Int) : Int;
418 }
419
420 llvm::endianness getDataEndianness() const {
421 if (!ShouldSwapBytes)
425 else
427 }
428
429 inline uint8_t getNumPaddingBytes(uint64_t SizeInBytes) {
430 return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t));
431 }
432
433 Error readName(NamedInstrProfRecord &Record);
434 Error readFuncHash(NamedInstrProfRecord &Record);
435 Error readRawCounts(InstrProfRecord &Record);
436 Error readRawBitmapBytes(InstrProfRecord &Record);
437 Error readValueProfilingData(InstrProfRecord &Record);
438 bool atEnd() const { return Data == DataEnd; }
439
440 void advanceData() {
441 // `CountersDelta` is a constant zero when using debug info correlation.
442 if (!Correlator) {
443 // The initial CountersDelta is the in-memory address difference between
444 // the data and counts sections:
445 // start(__llvm_prf_cnts) - start(__llvm_prf_data)
446 // As we advance to the next record, we maintain the correct CountersDelta
447 // with respect to the next record.
448 CountersDelta -= sizeof(*Data);
449 BitmapDelta -= sizeof(*Data);
450 }
451 Data++;
452 ValueDataStart += CurValueDataSize;
453 }
454
455 const char *getNextHeaderPos() const {
456 assert(atEnd());
457 return (const char *)ValueDataStart;
458 }
459
460 StringRef getName(uint64_t NameRef) const {
461 return Symtab->getFuncOrVarName(swap(NameRef));
462 }
463
464 int getCounterTypeSize() const {
465 return hasSingleByteCoverage() ? sizeof(uint8_t) : sizeof(uint64_t);
466 }
467};
468
471
472namespace IndexedInstrProf {
473
474enum class HashT : uint32_t;
475
476} // end namespace IndexedInstrProf
477
478/// Trait for lookups into the on-disk hash table for the binary instrprof
479/// format.
481 std::vector<NamedInstrProfRecord> DataBuffer;
483 unsigned FormatVersion;
484 // Endianness of the input value profile data.
485 // It should be LE by default, but can be changed
486 // for testing purpose.
487 llvm::endianness ValueProfDataEndianness = llvm::endianness::little;
488
489public:
490 InstrProfLookupTrait(IndexedInstrProf::HashT HashType, unsigned FormatVersion)
491 : HashType(HashType), FormatVersion(FormatVersion) {}
492
494
499
500 static bool EqualKey(StringRef A, StringRef B) { return A == B; }
501 static StringRef GetInternalKey(StringRef K) { return K; }
502 static StringRef GetExternalKey(StringRef K) { return K; }
503
505
506 static std::pair<offset_type, offset_type>
507 ReadKeyDataLength(const unsigned char *&D) {
508 using namespace support;
509
510 offset_type KeyLen =
511 endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
512 offset_type DataLen =
513 endian::readNext<offset_type, llvm::endianness::little, unaligned>(D);
514 return std::make_pair(KeyLen, DataLen);
515 }
516
517 StringRef ReadKey(const unsigned char *D, offset_type N) {
518 return StringRef((const char *)D, N);
519 }
520
521 bool readValueProfilingData(const unsigned char *&D,
522 const unsigned char *const End);
523 data_type ReadData(StringRef K, const unsigned char *D, offset_type N);
524
525 // Used for testing purpose only.
527 ValueProfDataEndianness = Endianness;
528 }
529};
530
532 virtual ~InstrProfReaderIndexBase() = default;
533
534 // Read all the profile records with the same key pointed to the current
535 // iterator.
537
538 // Read all the profile records with the key equal to FuncName
539 virtual Error getRecords(StringRef FuncName,
541 virtual void advanceToNextKey() = 0;
542 virtual bool atEnd() const = 0;
543 virtual void setValueProfDataEndianness(llvm::endianness Endianness) = 0;
544 virtual uint64_t getVersion() const = 0;
545 virtual bool isIRLevelProfile() const = 0;
546 virtual bool hasCSIRLevelProfile() const = 0;
547 virtual bool instrEntryBBEnabled() const = 0;
548 virtual bool hasSingleByteCoverage() const = 0;
549 virtual bool functionEntryOnly() const = 0;
550 virtual bool hasMemoryProfile() const = 0;
551 virtual bool hasTemporalProfile() const = 0;
552 virtual InstrProfKind getProfileKind() const = 0;
554};
555
558
563
564template <typename HashTableImpl>
566
567template <typename HashTableImpl>
569private:
570 std::unique_ptr<HashTableImpl> HashTable;
571 typename HashTableImpl::data_iterator RecordIterator;
572 uint64_t FormatVersion;
573
574 friend class InstrProfReaderItaniumRemapper<HashTableImpl>;
575
576public:
577 InstrProfReaderIndex(const unsigned char *Buckets,
578 const unsigned char *const Payload,
579 const unsigned char *const Base,
580 IndexedInstrProf::HashT HashType, uint64_t Version);
581 ~InstrProfReaderIndex() override = default;
582
584 Error getRecords(StringRef FuncName,
586 void advanceToNextKey() override { RecordIterator++; }
587
588 bool atEnd() const override {
589 return RecordIterator == HashTable->data_end();
590 }
591
593 HashTable->getInfoObj().setValueProfDataEndianness(Endianness);
594 }
595
596 uint64_t getVersion() const override { return GET_VERSION(FormatVersion); }
597
598 bool isIRLevelProfile() const override {
599 return (FormatVersion & VARIANT_MASK_IR_PROF) != 0;
600 }
601
602 bool hasCSIRLevelProfile() const override {
603 return (FormatVersion & VARIANT_MASK_CSIR_PROF) != 0;
604 }
605
606 bool instrEntryBBEnabled() const override {
607 return (FormatVersion & VARIANT_MASK_INSTR_ENTRY) != 0;
608 }
609
610 bool hasSingleByteCoverage() const override {
611 return (FormatVersion & VARIANT_MASK_BYTE_COVERAGE) != 0;
612 }
613
614 bool functionEntryOnly() const override {
615 return (FormatVersion & VARIANT_MASK_FUNCTION_ENTRY_ONLY) != 0;
616 }
617
618 bool hasMemoryProfile() const override {
619 return (FormatVersion & VARIANT_MASK_MEMPROF) != 0;
620 }
621
622 bool hasTemporalProfile() const override {
623 return (FormatVersion & VARIANT_MASK_TEMPORAL_PROF) != 0;
624 }
625
626 InstrProfKind getProfileKind() const override;
627
629 return Symtab.create(HashTable->keys());
630 }
631};
632
633/// Name matcher supporting fuzzy matching of symbol names to names in profiles.
635public:
636 virtual ~InstrProfReaderRemapper() = default;
638 virtual Error getRecords(StringRef FuncName,
640};
641
642/// Reader for the indexed binary instrprof format.
644private:
645 /// The profile data file contents.
646 std::unique_ptr<MemoryBuffer> DataBuffer;
647 /// The profile remapping file contents.
648 std::unique_ptr<MemoryBuffer> RemappingBuffer;
649 /// The index into the profile data.
650 std::unique_ptr<InstrProfReaderIndexBase> Index;
651 /// The profile remapping file contents.
652 std::unique_ptr<InstrProfReaderRemapper> Remapper;
653 /// Profile summary data.
654 std::unique_ptr<ProfileSummary> Summary;
655 /// Context sensitive profile summary data.
656 std::unique_ptr<ProfileSummary> CS_Summary;
657 /// MemProf profile schema (if available).
659 /// MemProf record profile data on-disk indexed via llvm::md5(FunctionName).
660 std::unique_ptr<MemProfRecordHashTable> MemProfRecordTable;
661 /// MemProf frame profile data on-disk indexed via frame id.
662 std::unique_ptr<MemProfFrameHashTable> MemProfFrameTable;
663 /// VTableNamePtr points to the beginning of compressed vtable names.
664 /// When a symtab is constructed from profiles by llvm-profdata, the list of
665 /// names could be decompressed based on `VTableNamePtr` and
666 /// `CompressedVTableNamesLen`.
667 /// A compiler that reads indexed profiles could construct symtab from module
668 /// IR so it doesn't need the decompressed names.
669 const char *VTableNamePtr = nullptr;
670 /// The length of compressed vtable names.
671 uint64_t CompressedVTableNamesLen = 0;
672 /// Total size of binary ids.
673 uint64_t BinaryIdsSize{0};
674 /// Start address of binary id length and data pairs.
675 const uint8_t *BinaryIdsStart = nullptr;
676
677 // Index to the current record in the record array.
678 unsigned RecordIndex;
679
680 // Read the profile summary. Return a pointer pointing to one byte past the
681 // end of the summary data if it exists or the input \c Cur.
682 // \c UseCS indicates whether to use the context-sensitive profile summary.
683 const unsigned char *readSummary(IndexedInstrProf::ProfVersion Version,
684 const unsigned char *Cur, bool UseCS);
685
686public:
688 std::unique_ptr<MemoryBuffer> DataBuffer,
689 std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr)
690 : DataBuffer(std::move(DataBuffer)),
691 RemappingBuffer(std::move(RemappingBuffer)), RecordIndex(0) {}
694
695 /// Return the profile version.
696 uint64_t getVersion() const override { return Index->getVersion(); }
697 bool isIRLevelProfile() const override { return Index->isIRLevelProfile(); }
698 bool hasCSIRLevelProfile() const override {
699 return Index->hasCSIRLevelProfile();
700 }
701
702 bool instrEntryBBEnabled() const override {
703 return Index->instrEntryBBEnabled();
704 }
705
706 bool hasSingleByteCoverage() const override {
707 return Index->hasSingleByteCoverage();
708 }
709
710 bool functionEntryOnly() const override { return Index->functionEntryOnly(); }
711
712 bool hasMemoryProfile() const override { return Index->hasMemoryProfile(); }
713
714 bool hasTemporalProfile() const override {
715 return Index->hasTemporalProfile();
716 }
717
718 /// Returns a BitsetEnum describing the attributes of the indexed instr
719 /// profile.
720 InstrProfKind getProfileKind() const override {
721 return Index->getProfileKind();
722 }
723
724 /// Return true if the given buffer is in an indexed instrprof format.
725 static bool hasFormat(const MemoryBuffer &DataBuffer);
726
727 /// Read the file header.
728 Error readHeader() override;
729 /// Read a single record.
731
732 /// Return the NamedInstrProfRecord associated with FuncName and FuncHash.
733 /// When return a hash_mismatch error and MismatchedFuncSum is not nullptr,
734 /// the sum of all counters in the mismatched function will be set to
735 /// MismatchedFuncSum. If there are multiple instances of mismatched
736 /// functions, MismatchedFuncSum returns the maximum. If \c FuncName is not
737 /// found, try to lookup \c DeprecatedFuncName to handle profiles built by
738 /// older compilers.
740 getInstrProfRecord(StringRef FuncName, uint64_t FuncHash,
741 StringRef DeprecatedFuncName = "",
742 uint64_t *MismatchedFuncSum = nullptr);
743
744 /// Return the memprof record for the function identified by
745 /// llvm::md5(Name).
747
748 /// Fill Counts with the profile data for the given function name.
749 Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
750 std::vector<uint64_t> &Counts);
751
752 /// Fill Bitmap with the profile data for the given function name.
753 Error getFunctionBitmap(StringRef FuncName, uint64_t FuncHash,
754 BitVector &Bitmap);
755
756 /// Return the maximum of all known function counts.
757 /// \c UseCS indicates whether to use the context-sensitive count.
759 if (UseCS) {
760 assert(CS_Summary && "No context sensitive profile summary");
761 return CS_Summary->getMaxFunctionCount();
762 } else {
763 assert(Summary && "No profile summary");
764 return Summary->getMaxFunctionCount();
765 }
766 }
767
768 /// Factory method to create an indexed reader.
770 create(const Twine &Path, vfs::FileSystem &FS,
771 const Twine &RemappingPath = "");
772
774 create(std::unique_ptr<MemoryBuffer> Buffer,
775 std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr);
776
777 // Used for testing purpose only.
779 Index->setValueProfDataEndianness(Endianness);
780 }
781
782 // See description in the base class. This interface is designed
783 // to be used by llvm-profdata (for dumping). Avoid using this when
784 // the client is the compiler.
785 InstrProfSymtab &getSymtab() override;
786
787 /// Return the profile summary.
788 /// \c UseCS indicates whether to use the context-sensitive summary.
790 if (UseCS) {
791 assert(CS_Summary && "No context sensitive summary");
792 return *CS_Summary;
793 } else {
794 assert(Summary && "No profile summary");
795 return *Summary;
796 }
797 }
798
799 Error readBinaryIds(std::vector<llvm::object::BuildID> &BinaryIds) override;
801};
802
803} // end namespace llvm
804
805#endif // LLVM_PROFILEDATA_INSTRPROFREADER_H
aarch64 promote const
basic Basic Alias true
This file declares a library for handling Build IDs and using them to find debug info.
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
bool End
Definition: ELF_riscv.cpp:480
InstrProfLookupTrait::offset_type offset_type
InstrProfLookupTrait::data_type data_type
Defines facilities for reading and writing on-disk hash tables.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
#define error(X)
Value * RHS
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Lightweight error class with error context and mandatory checking.
Definition: Error.h:160
static ErrorSuccess success()
Create a success value.
Definition: Error.h:334
Tagged union holding either a T or a Error.
Definition: Error.h:474
Reader for the indexed binary instrprof format.
uint64_t getVersion() const override
Return the profile version.
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
static Expected< std::unique_ptr< IndexedInstrProfReader > > create(const Twine &Path, vfs::FileSystem &FS, const Twine &RemappingPath="")
Factory method to create an indexed reader.
IndexedInstrProfReader(const IndexedInstrProfReader &)=delete
Expected< memprof::MemProfRecord > getMemProfRecord(uint64_t FuncNameHash)
Return the memprof record for the function identified by llvm::md5(Name).
Error readHeader() override
Read the file header.
Error printBinaryIds(raw_ostream &OS) override
Print binary ids.
bool hasTemporalProfile() const override
Return true if this has a temporal profile.
Error getFunctionBitmap(StringRef FuncName, uint64_t FuncHash, BitVector &Bitmap)
Fill Bitmap with the profile data for the given function name.
bool hasSingleByteCoverage() const override
Return true if the profile has single byte counters representing coverage.
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
ProfileSummary & getSummary(bool UseCS)
Return the profile summary.
static bool hasFormat(const MemoryBuffer &DataBuffer)
Return true if the given buffer is in an indexed instrprof format.
Expected< InstrProfRecord > getInstrProfRecord(StringRef FuncName, uint64_t FuncHash, StringRef DeprecatedFuncName="", uint64_t *MismatchedFuncSum=nullptr)
Return the NamedInstrProfRecord associated with FuncName and FuncHash.
bool hasMemoryProfile() const override
Return true if profile includes a memory profile.
bool functionEntryOnly() const override
Return true if the profile only instruments function entries.
uint64_t getMaximumFunctionCount(bool UseCS)
Return the maximum of all known function counts.
Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash, std::vector< uint64_t > &Counts)
Fill Counts with the profile data for the given function name.
InstrProfKind getProfileKind() const override
Returns a BitsetEnum describing the attributes of the indexed instr profile.
void setValueProfDataEndianness(llvm::endianness Endianness)
IndexedInstrProfReader(std::unique_ptr< MemoryBuffer > DataBuffer, std::unique_ptr< MemoryBuffer > RemappingBuffer=nullptr)
Error readBinaryIds(std::vector< llvm::object::BuildID > &BinaryIds) override
Read a list of binary ids.
bool hasCSIRLevelProfile() const override
IndexedInstrProfReader & operator=(const IndexedInstrProfReader &)=delete
bool instrEntryBBEnabled() const override
bool isIRLevelProfile() const override
InstrProfCorrelatorImpl - A child of InstrProfCorrelator with a template pointer type so that the Pro...
InstrProfCorrelator - A base class used to create raw instrumentation data to their functions.
static std::pair< instrprof_error, std::string > take(Error E)
Consume an Error and return the raw enum value contained within it, and the optional error message.
Definition: InstrProf.h:394
const std::string & getMessage() const
Definition: InstrProf.h:389
instrprof_error get() const
Definition: InstrProf.h:388
A file format agnostic iterator over profiling data.
bool operator==(const InstrProfIterator &RHS) const
value_type & operator*()
InstrProfIterator(reader_type *Reader)
InstrProfIterator & operator++()
bool operator!=(const InstrProfIterator &RHS) const
value_type * operator->()
std::ptrdiff_t difference_type
std::input_iterator_tag iterator_category
Trait for lookups into the on-disk hash table for the binary instrprof format.
InstrProfLookupTrait(IndexedInstrProf::HashT HashType, unsigned FormatVersion)
void setValueProfDataEndianness(llvm::endianness Endianness)
StringRef ReadKey(const unsigned char *D, offset_type N)
static std::pair< offset_type, offset_type > ReadKeyDataLength(const unsigned char *&D)
static StringRef GetExternalKey(StringRef K)
data_type ReadData(StringRef K, const unsigned char *D, offset_type N)
bool readValueProfilingData(const unsigned char *&D, const unsigned char *const End)
hash_value_type ComputeHash(StringRef K)
static bool EqualKey(StringRef A, StringRef B)
static StringRef GetInternalKey(StringRef K)
Error populateSymtab(InstrProfSymtab &Symtab) override
bool hasSingleByteCoverage() const override
void advanceToNextKey() override
bool hasCSIRLevelProfile() const override
void setValueProfDataEndianness(llvm::endianness Endianness) override
InstrProfKind getProfileKind() const override
Error getRecords(ArrayRef< NamedInstrProfRecord > &Data) override
bool functionEntryOnly() const override
~InstrProfReaderIndex() override=default
uint64_t getVersion() const override
bool isIRLevelProfile() const override
bool hasMemoryProfile() const override
bool hasTemporalProfile() const override
bool instrEntryBBEnabled() const override
bool atEnd() const override
A remapper that applies remappings based on a symbol remapping file.
Name matcher supporting fuzzy matching of symbol names to names in profiles.
virtual Error getRecords(StringRef FuncName, ArrayRef< NamedInstrProfRecord > &Data)=0
virtual ~InstrProfReaderRemapper()=default
Base class and interface for reading profiling data of any known instrprof format.
InstrProfIterator begin()
Iterator over profile data.
virtual bool instrEntryBBEnabled() const =0
virtual Error readNextRecord(NamedInstrProfRecord &Record)=0
Read a single record.
Error error(Error &&E)
InstrProfIterator end()
virtual Error readBinaryIds(std::vector< llvm::object::BuildID > &BinaryIds)
Read a list of binary ids.
virtual bool functionEntryOnly() const =0
Return true if the profile only instruments function entries.
std::unique_ptr< InstrProfSymtab > Symtab
Error getError()
Get the current error.
virtual InstrProfSymtab & getSymtab()=0
Return the PGO symtab.
virtual bool hasSingleByteCoverage() const =0
Return true if the profile has single byte counters representing coverage.
virtual bool hasTemporalProfile() const =0
Return true if this has a temporal profile.
Error success()
Clear the current error and return a successful one.
bool hasError()
Return true if the reader encountered an error reading profiling data.
virtual InstrProfKind getProfileKind() const =0
Returns a BitsetEnum describing the attributes of the profile.
SmallVector< TemporalProfTraceTy > TemporalProfTraces
A list of temporal profile traces.
uint64_t TemporalProfTraceStreamSize
The total number of temporal profile traces seen.
virtual Error printBinaryIds(raw_ostream &OS)
Print binary ids.
uint64_t getTemporalProfTraceStreamSize()
virtual uint64_t getVersion() const =0
Return the profile version.
virtual bool hasMemoryProfile() const =0
Return true if profile includes a memory profile.
virtual SmallVector< TemporalProfTraceTy > & getTemporalProfTraces(std::optional< uint64_t > Weight={})
static Expected< std::unique_ptr< InstrProfReader > > create(const Twine &Path, vfs::FileSystem &FS, const InstrProfCorrelator *Correlator=nullptr, std::function< void(Error)> Warn=nullptr)
Factory method to create an appropriately typed reader for the given instrprof file.
virtual bool hasCSIRLevelProfile() const =0
virtual bool isIRLevelProfile() const =0
virtual ~InstrProfReader()=default
virtual Error readHeader()=0
Read the header. Required before reading first record.
Error error(instrprof_error Err, const std::string &ErrMsg="")
Set the current error and return same.
void accumulateCounts(CountSumOrPercent &Sum, bool IsCS)
Compute the sum of counts and return in Sum.
bool isEOF()
Return true if the reader has finished reading the profile data.
A symbol table used for function [IR]PGO name look-up with keys (such as pointers,...
Definition: InstrProf.h:429
Error create(object::SectionRef &Section)
Create InstrProfSymtab from an object file section which contains function PGO names.
This interface provides simple read-only access to a block of memory, and provides simple methods for...
Definition: MemoryBuffer.h:51
Provides lookup and iteration over an on disk hash table.
Reader for the raw instrprof binary format from runtime.
bool functionEntryOnly() const override
Return true if the profile only instruments function entries.
Error readHeader() override
Read the header. Required before reading first record.
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
Error printBinaryIds(raw_ostream &OS) override
Print binary ids.
static bool hasFormat(const MemoryBuffer &DataBuffer)
RawInstrProfReader & operator=(const RawInstrProfReader &)=delete
RawInstrProfReader(std::unique_ptr< MemoryBuffer > DataBuffer, const InstrProfCorrelator *Correlator, std::function< void(Error)> Warn)
bool hasSingleByteCoverage() const override
Return true if the profile has single byte counters representing coverage.
bool isIRLevelProfile() const override
InstrProfKind getProfileKind() const override
Returns a BitsetEnum describing the attributes of the raw instr profile.
bool hasMemoryProfile() const override
Return true if profile includes a memory profile.
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
Error readBinaryIds(std::vector< llvm::object::BuildID > &BinaryIds) override
Read a list of binary ids.
bool hasTemporalProfile() const override
Return true if this has a temporal profile.
bool instrEntryBBEnabled() const override
uint64_t getVersion() const override
Return the profile version.
SmallVector< TemporalProfTraceTy > & getTemporalProfTraces(std::optional< uint64_t > Weight={}) override
RawInstrProfReader(const RawInstrProfReader &)=delete
bool hasCSIRLevelProfile() const override
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
Reader for the simple text based instrprof format.
bool isIRLevelProfile() const override
uint64_t getVersion() const override
Return the profile version.
static bool hasFormat(const MemoryBuffer &Buffer)
Return true if the given buffer is in text instrprof format.
TextInstrProfReader(std::unique_ptr< MemoryBuffer > DataBuffer_)
bool hasSingleByteCoverage() const override
Return true if the profile has single byte counters representing coverage.
Error readNextRecord(NamedInstrProfRecord &Record) override
Read a single record.
TextInstrProfReader(const TextInstrProfReader &)=delete
bool hasMemoryProfile() const override
Return true if profile includes a memory profile.
bool hasCSIRLevelProfile() const override
InstrProfSymtab & getSymtab() override
Return the PGO symtab.
bool instrEntryBBEnabled() const override
bool functionEntryOnly() const override
Return true if the profile only instruments function entries.
InstrProfKind getProfileKind() const override
Returns a BitsetEnum describing the attributes of the profile.
bool hasTemporalProfile() const override
Return true if this has a temporal profile.
Error readHeader() override
Read the header.
TextInstrProfReader & operator=(const TextInstrProfReader &)=delete
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
A forward iterator which reads text lines from a buffer.
Definition: LineIterator.h:33
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
The virtual file system interface.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
constexpr T byteswap(T V) noexcept
Reverses the bytes in the given integer value V.
Definition: bit.h:101
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:970
auto dyn_cast_or_null(const Y &Val)
Definition: Casting.h:759
instrprof_error
Definition: InstrProf.h:324
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1858
endianness
Definition: bit.h:70
InstrProfKind
An enum describing the attributes of an instrumented profile.
Definition: InstrProf.h:301
Implement std::hash so that hash_code can be used in STL containers.
Definition: BitVector.h:858
#define N
virtual Error populateSymtab(InstrProfSymtab &)=0
virtual Error getRecords(ArrayRef< NamedInstrProfRecord > &Data)=0
virtual ~InstrProfReaderIndexBase()=default
virtual InstrProfKind getProfileKind() const =0
virtual bool hasTemporalProfile() const =0
virtual bool isIRLevelProfile() const =0
virtual void advanceToNextKey()=0
virtual bool hasMemoryProfile() const =0
virtual bool hasCSIRLevelProfile() const =0
virtual uint64_t getVersion() const =0
virtual bool atEnd() const =0
virtual bool instrEntryBBEnabled() const =0
virtual Error getRecords(StringRef FuncName, ArrayRef< NamedInstrProfRecord > &Data)=0
virtual void setValueProfDataEndianness(llvm::endianness Endianness)=0
virtual bool functionEntryOnly() const =0
virtual bool hasSingleByteCoverage() const =0
Profiling information for a single function.
Definition: InstrProf.h:704