1 //=-- InstrProfReader.cpp - Instrumented profiling reader -------------------=//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains support for reading profiling data for clang's
11 // instrumentation based PGO and coverage.
13 //===----------------------------------------------------------------------===//
15 #include "llvm/ProfileData/InstrProfReader.h"
16 #include "llvm/ProfileData/InstrProf.h"
22 error_code InstrProfReader::create(std::string Path,
23 std::unique_ptr<InstrProfReader> &Result) {
24 std::unique_ptr<MemoryBuffer> Buffer;
25 if (error_code EC = MemoryBuffer::getFileOrSTDIN(Path, Buffer))
28 // Sanity check the file.
29 if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
30 return instrprof_error::too_large;
33 if (RawInstrProfReader64::hasFormat(*Buffer))
34 Result.reset(new RawInstrProfReader64(std::move(Buffer)));
35 else if (RawInstrProfReader32::hasFormat(*Buffer))
36 Result.reset(new RawInstrProfReader32(std::move(Buffer)));
38 Result.reset(new TextInstrProfReader(std::move(Buffer)));
40 // Read the header and return the result.
41 return Result->readHeader();
44 void InstrProfIterator::Increment() {
45 if (Reader->readNextRecord(Record))
46 *this = InstrProfIterator();
49 error_code TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
51 while (!Line.is_at_end() && Line->empty())
53 // If we hit EOF while looking for a name, we're done.
55 return error(instrprof_error::eof);
57 // Read the function name.
58 Record.Name = *Line++;
60 // Read the function hash.
62 return error(instrprof_error::truncated);
63 if ((Line++)->getAsInteger(10, Record.Hash))
64 return error(instrprof_error::malformed);
66 // Read the number of counters.
69 return error(instrprof_error::truncated);
70 if ((Line++)->getAsInteger(10, NumCounters))
71 return error(instrprof_error::malformed);
73 // Read each counter and fill our internal storage with the values.
75 Counts.reserve(NumCounters);
76 for (uint64_t I = 0; I < NumCounters; ++I) {
78 return error(instrprof_error::truncated);
80 if ((Line++)->getAsInteger(10, Count))
81 return error(instrprof_error::malformed);
82 Counts.push_back(Count);
84 // Give the record a reference to our internal counter storage.
85 Record.Counts = Counts;
90 template <class IntPtrT>
91 static uint64_t getRawMagic();
94 uint64_t getRawMagic<uint64_t>() {
100 uint64_t('o') << 24 |
101 uint64_t('f') << 16 |
107 uint64_t getRawMagic<uint32_t>() {
109 uint64_t(255) << 56 |
110 uint64_t('l') << 48 |
111 uint64_t('p') << 40 |
112 uint64_t('r') << 32 |
113 uint64_t('o') << 24 |
114 uint64_t('f') << 16 |
119 template <class IntPtrT>
120 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
121 if (DataBuffer.getBufferSize() < sizeof(uint64_t))
124 *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
125 return getRawMagic<IntPtrT>() == Magic ||
126 sys::SwapByteOrder(getRawMagic<IntPtrT>()) == Magic;
129 template <class IntPtrT>
130 error_code RawInstrProfReader<IntPtrT>::readHeader() {
131 if (!hasFormat(*DataBuffer))
132 return error(instrprof_error::bad_magic);
133 if (DataBuffer->getBufferSize() < sizeof(RawHeader))
134 return error(instrprof_error::bad_header);
136 reinterpret_cast<const RawHeader *>(DataBuffer->getBufferStart());
137 ShouldSwapBytes = Header->Magic != getRawMagic<IntPtrT>();
138 return readHeader(*Header);
141 static uint64_t getRawVersion() {
145 template <class IntPtrT>
146 error_code RawInstrProfReader<IntPtrT>::readHeader(const RawHeader &Header) {
147 if (swap(Header.Version) != getRawVersion())
148 return error(instrprof_error::unsupported_version);
150 CountersDelta = swap(Header.CountersDelta);
151 NamesDelta = swap(Header.NamesDelta);
152 auto DataSize = swap(Header.DataSize);
153 auto CountersSize = swap(Header.CountersSize);
154 auto NamesSize = swap(Header.NamesSize);
156 ptrdiff_t DataOffset = sizeof(RawHeader);
157 ptrdiff_t CountersOffset = DataOffset + sizeof(ProfileData) * DataSize;
158 ptrdiff_t NamesOffset = CountersOffset + sizeof(uint64_t) * CountersSize;
159 size_t FileSize = NamesOffset + sizeof(char) * NamesSize;
161 if (FileSize != DataBuffer->getBufferSize())
162 return error(instrprof_error::bad_header);
164 const char *Start = DataBuffer->getBufferStart();
165 Data = reinterpret_cast<const ProfileData *>(Start + DataOffset);
166 DataEnd = Data + DataSize;
167 CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
168 NamesStart = Start + NamesOffset;
173 template <class IntPtrT>
175 RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
177 return error(instrprof_error::eof);
180 StringRef RawName(getName(Data->NamePtr), swap(Data->NameSize));
181 auto RawCounts = makeArrayRef(getCounter(Data->CounterPtr),
182 swap(Data->NumCounters));
185 auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
186 if (RawName.data() < NamesStart ||
187 RawName.data() + RawName.size() > DataBuffer->getBufferEnd() ||
188 RawCounts.data() < CountersStart ||
189 RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
190 return error(instrprof_error::malformed);
192 // Store the data in Record, byte-swapping as necessary.
193 Record.Hash = swap(Data->FuncHash);
194 Record.Name = RawName;
195 if (ShouldSwapBytes) {
197 Counts.reserve(RawCounts.size());
198 for (uint64_t Count : RawCounts)
199 Counts.push_back(swap(Count));
200 Record.Counts = Counts;
202 Record.Counts = RawCounts;
210 template class RawInstrProfReader<uint32_t>;
211 template class RawInstrProfReader<uint64_t>;