LLVM 20.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>(D);
512 offset_type DataLen =
513 endian::readNext<offset_type, llvm::endianness::little>(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
565
566template <typename HashTableImpl>
568
569template <typename HashTableImpl>
571private:
572 std::unique_ptr<HashTableImpl> HashTable;
573 typename HashTableImpl::data_iterator RecordIterator;
574 uint64_t FormatVersion;
575
576 friend class InstrProfReaderItaniumRemapper<HashTableImpl>;
577
578public:
579 InstrProfReaderIndex(const unsigned char *Buckets,
580 const unsigned char *const Payload,
581 const unsigned char *const Base,
583 ~InstrProfReaderIndex() override = default;
584
586 Error getRecords(StringRef FuncName,
588 void advanceToNextKey() override { RecordIterator++; }
589
590 bool atEnd() const override {
591 return RecordIterator == HashTable->data_end();
592 }
593
595 HashTable->getInfoObj().setValueProfDataEndianness(Endianness);
596 }
597
598 uint64_t getVersion() const override { return GET_VERSION(FormatVersion); }
599
600 bool isIRLevelProfile() const override {
601 return (FormatVersion & VARIANT_MASK_IR_PROF) != 0;
602 }
603
604 bool hasCSIRLevelProfile() const override {
605 return (FormatVersion & VARIANT_MASK_CSIR_PROF) != 0;
606 }
607
608 bool instrEntryBBEnabled() const override {
609 return (FormatVersion & VARIANT_MASK_INSTR_ENTRY) != 0;
610 }
611
612 bool hasSingleByteCoverage() const override {
613 return (FormatVersion & VARIANT_MASK_BYTE_COVERAGE) != 0;
614 }
615
616 bool functionEntryOnly() const override {
617 return (FormatVersion & VARIANT_MASK_FUNCTION_ENTRY_ONLY) != 0;
618 }
619
620 bool hasMemoryProfile() const override {
621 return (FormatVersion & VARIANT_MASK_MEMPROF) != 0;
622 }
623
624 bool hasTemporalProfile() const override {
625 return (FormatVersion & VARIANT_MASK_TEMPORAL_PROF) != 0;
626 }
627
628 InstrProfKind getProfileKind() const override;
629
631 // FIXME: the create method calls 'finalizeSymtab' and sorts a bunch of
632 // arrays/maps. Since there are other data sources other than 'HashTable' to
633 // populate a symtab, it might make sense to have something like this
634 // 1. Let each data source populate Symtab and init the arrays/maps without
635 // calling 'finalizeSymtab'
636 // 2. Call 'finalizeSymtab' once to get all arrays/maps sorted if needed.
637 return Symtab.create(HashTable->keys());
638 }
639};
640
641/// Name matcher supporting fuzzy matching of symbol names to names in profiles.
643public:
644 virtual ~InstrProfReaderRemapper() = default;
646 virtual Error getRecords(StringRef FuncName,
648};
649
651private:
652 /// The MemProf version.
654 /// MemProf profile schema (if available).
656 /// MemProf record profile data on-disk indexed via llvm::md5(FunctionName).
657 std::unique_ptr<MemProfRecordHashTable> MemProfRecordTable;
658 /// MemProf frame profile data on-disk indexed via frame id.
659 std::unique_ptr<MemProfFrameHashTable> MemProfFrameTable;
660 /// MemProf call stack data on-disk indexed via call stack id.
661 std::unique_ptr<MemProfCallStackHashTable> MemProfCallStackTable;
662 /// The starting address of the frame array.
663 const unsigned char *FrameBase = nullptr;
664 /// The starting address of the call stack array.
665 const unsigned char *CallStackBase = nullptr;
666
667 Error deserializeV012(const unsigned char *Start, const unsigned char *Ptr,
668 uint64_t FirstWord);
669 Error deserializeV3(const unsigned char *Start, const unsigned char *Ptr);
670
671public:
673
674 Error deserialize(const unsigned char *Start, uint64_t MemProfOffset);
675
677 getMemProfRecord(const uint64_t FuncNameHash) const;
678};
679
680/// Reader for the indexed binary instrprof format.
682private:
683 /// The profile data file contents.
684 std::unique_ptr<MemoryBuffer> DataBuffer;
685 /// The profile remapping file contents.
686 std::unique_ptr<MemoryBuffer> RemappingBuffer;
687 /// The index into the profile data.
688 std::unique_ptr<InstrProfReaderIndexBase> Index;
689 /// The profile remapping file contents.
690 std::unique_ptr<InstrProfReaderRemapper> Remapper;
691 /// Profile summary data.
692 std::unique_ptr<ProfileSummary> Summary;
693 /// Context sensitive profile summary data.
694 std::unique_ptr<ProfileSummary> CS_Summary;
695 IndexedMemProfReader MemProfReader;
696 /// The compressed vtable names, to be used for symtab construction.
697 /// A compiler that reads indexed profiles could construct symtab from module
698 /// IR so it doesn't need the decompressed names.
699 StringRef VTableName;
700 /// A memory buffer holding binary ids.
701 ArrayRef<uint8_t> BinaryIdsBuffer;
702
703 // Index to the current record in the record array.
704 unsigned RecordIndex = 0;
705
706 // Read the profile summary. Return a pointer pointing to one byte past the
707 // end of the summary data if it exists or the input \c Cur.
708 // \c UseCS indicates whether to use the context-sensitive profile summary.
709 const unsigned char *readSummary(IndexedInstrProf::ProfVersion Version,
710 const unsigned char *Cur, bool UseCS);
711
712public:
714 std::unique_ptr<MemoryBuffer> DataBuffer,
715 std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr)
716 : DataBuffer(std::move(DataBuffer)),
717 RemappingBuffer(std::move(RemappingBuffer)) {}
720
721 /// Return the profile version.
722 uint64_t getVersion() const override { return Index->getVersion(); }
723 bool isIRLevelProfile() const override { return Index->isIRLevelProfile(); }
724 bool hasCSIRLevelProfile() const override {
725 return Index->hasCSIRLevelProfile();
726 }
727
728 bool instrEntryBBEnabled() const override {
729 return Index->instrEntryBBEnabled();
730 }
731
732 bool hasSingleByteCoverage() const override {
733 return Index->hasSingleByteCoverage();
734 }
735
736 bool functionEntryOnly() const override { return Index->functionEntryOnly(); }
737
738 bool hasMemoryProfile() const override { return Index->hasMemoryProfile(); }
739
740 bool hasTemporalProfile() const override {
741 return Index->hasTemporalProfile();
742 }
743
744 /// Returns a BitsetEnum describing the attributes of the indexed instr
745 /// profile.
746 InstrProfKind getProfileKind() const override {
747 return Index->getProfileKind();
748 }
749
750 /// Return true if the given buffer is in an indexed instrprof format.
751 static bool hasFormat(const MemoryBuffer &DataBuffer);
752
753 /// Read the file header.
754 Error readHeader() override;
755 /// Read a single record.
757
758 /// Return the NamedInstrProfRecord associated with FuncName and FuncHash.
759 /// When return a hash_mismatch error and MismatchedFuncSum is not nullptr,
760 /// the sum of all counters in the mismatched function will be set to
761 /// MismatchedFuncSum. If there are multiple instances of mismatched
762 /// functions, MismatchedFuncSum returns the maximum. If \c FuncName is not
763 /// found, try to lookup \c DeprecatedFuncName to handle profiles built by
764 /// older compilers.
766 getInstrProfRecord(StringRef FuncName, uint64_t FuncHash,
767 StringRef DeprecatedFuncName = "",
768 uint64_t *MismatchedFuncSum = nullptr);
769
770 /// Return the memprof record for the function identified by
771 /// llvm::md5(Name).
773 return MemProfReader.getMemProfRecord(FuncNameHash);
774 }
775
776 /// Fill Counts with the profile data for the given function name.
777 Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
778 std::vector<uint64_t> &Counts);
779
780 /// Fill Bitmap with the profile data for the given function name.
781 Error getFunctionBitmap(StringRef FuncName, uint64_t FuncHash,
782 BitVector &Bitmap);
783
784 /// Return the maximum of all known function counts.
785 /// \c UseCS indicates whether to use the context-sensitive count.
787 if (UseCS) {
788 assert(CS_Summary && "No context sensitive profile summary");
789 return CS_Summary->getMaxFunctionCount();
790 } else {
791 assert(Summary && "No profile summary");
792 return Summary->getMaxFunctionCount();
793 }
794 }
795
796 /// Factory method to create an indexed reader.
798 create(const Twine &Path, vfs::FileSystem &FS,
799 const Twine &RemappingPath = "");
800
802 create(std::unique_ptr<MemoryBuffer> Buffer,
803 std::unique_ptr<MemoryBuffer> RemappingBuffer = nullptr);
804
805 // Used for testing purpose only.
807 Index->setValueProfDataEndianness(Endianness);
808 }
809
810 // See description in the base class. This interface is designed
811 // to be used by llvm-profdata (for dumping). Avoid using this when
812 // the client is the compiler.
813 InstrProfSymtab &getSymtab() override;
814
815 /// Return the profile summary.
816 /// \c UseCS indicates whether to use the context-sensitive summary.
818 if (UseCS) {
819 assert(CS_Summary && "No context sensitive summary");
820 return *CS_Summary;
821 } else {
822 assert(Summary && "No profile summary");
823 return *Summary;
824 }
825 }
826
827 Error readBinaryIds(std::vector<llvm::object::BuildID> &BinaryIds) override;
829};
830
831} // end namespace llvm
832
833#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:337
Tagged union holding either a T or a Error.
Definition: Error.h:481
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
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.
Expected< memprof::MemProfRecord > getMemProfRecord(uint64_t FuncNameHash)
Return the memprof record for the function identified by llvm::md5(Name).
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
Error deserialize(const unsigned char *Start, uint64_t MemProfOffset)
Expected< memprof::MemProfRecord > getMemProfRecord(const uint64_t FuncNameHash) const
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:419
const std::string & getMessage() const
Definition: InstrProf.h:414
instrprof_error get() const
Definition: InstrProf.h:413
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:454
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:977
auto dyn_cast_or_null(const Y &Val)
Definition: Casting.h:759
instrprof_error
Definition: InstrProf.h:348
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:1856
endianness
Definition: bit.h:70
InstrProfKind
An enum describing the attributes of an instrumented profile.
Definition: InstrProf.h:325
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:827