1 //=-- InstrProfReader.cpp - Instrumented profiling reader -------------------=//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for reading profiling data for clang's
11 // instrumentation based PGO and coverage.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "llvm/ProfileData/InstrProfReader.h"
16 #include "llvm/ProfileData/InstrProf.h"
17 
18 #include <cassert>
19 
20 using namespace llvm;
21 
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))
26     return EC;
27 
28   // Sanity check the file.
29   if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
30     return instrprof_error::too_large;
31 
32   // Create the reader.
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)));
37   else
38     Result.reset(new TextInstrProfReader(std::move(Buffer)));
39 
40   // Read the header and return the result.
41   return Result->readHeader();
42 }
43 
44 void InstrProfIterator::Increment() {
45   if (Reader->readNextRecord(Record))
46     *this = InstrProfIterator();
47 }
48 
49 error_code TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
50   // Skip empty lines.
51   while (!Line.is_at_end() && Line->empty())
52     ++Line;
53   // If we hit EOF while looking for a name, we're done.
54   if (Line.is_at_end())
55     return error(instrprof_error::eof);
56 
57   // Read the function name.
58   Record.Name = *Line++;
59 
60   // Read the function hash.
61   if (Line.is_at_end())
62     return error(instrprof_error::truncated);
63   if ((Line++)->getAsInteger(10, Record.Hash))
64     return error(instrprof_error::malformed);
65 
66   // Read the number of counters.
67   uint64_t NumCounters;
68   if (Line.is_at_end())
69     return error(instrprof_error::truncated);
70   if ((Line++)->getAsInteger(10, NumCounters))
71     return error(instrprof_error::malformed);
72 
73   // Read each counter and fill our internal storage with the values.
74   Counts.clear();
75   Counts.reserve(NumCounters);
76   for (uint64_t I = 0; I < NumCounters; ++I) {
77     if (Line.is_at_end())
78       return error(instrprof_error::truncated);
79     uint64_t Count;
80     if ((Line++)->getAsInteger(10, Count))
81       return error(instrprof_error::malformed);
82     Counts.push_back(Count);
83   }
84   // Give the record a reference to our internal counter storage.
85   Record.Counts = Counts;
86 
87   return success();
88 }
89 
90 template <class IntPtrT>
91 static uint64_t getRawMagic();
92 
93 template <>
94 uint64_t getRawMagic<uint64_t>() {
95   return
96     uint64_t(255) << 56 |
97     uint64_t('l') << 48 |
98     uint64_t('p') << 40 |
99     uint64_t('r') << 32 |
100     uint64_t('o') << 24 |
101     uint64_t('f') << 16 |
102     uint64_t('r') <<  8 |
103     uint64_t(129);
104 }
105 
106 template <>
107 uint64_t getRawMagic<uint32_t>() {
108   return
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 |
115     uint64_t('R') <<  8 |
116     uint64_t(129);
117 }
118 
119 template <class IntPtrT>
120 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
121   if (DataBuffer.getBufferSize() < sizeof(uint64_t))
122     return false;
123   uint64_t Magic =
124     *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
125   return getRawMagic<IntPtrT>() == Magic ||
126     sys::SwapByteOrder(getRawMagic<IntPtrT>()) == Magic;
127 }
128 
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);
135   auto *Header =
136     reinterpret_cast<const RawHeader *>(DataBuffer->getBufferStart());
137   ShouldSwapBytes = Header->Magic != getRawMagic<IntPtrT>();
138   return readHeader(*Header);
139 }
140 
141 static uint64_t getRawVersion() {
142   return 1;
143 }
144 
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);
149 
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);
155 
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;
160 
161   if (FileSize != DataBuffer->getBufferSize())
162     return error(instrprof_error::bad_header);
163 
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;
169 
170   return success();
171 }
172 
173 template <class IntPtrT>
174 error_code
175 RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
176   if (Data == DataEnd)
177     return error(instrprof_error::eof);
178 
179   // Get the raw data.
180   StringRef RawName(getName(Data->NamePtr), swap(Data->NameSize));
181   auto RawCounts = makeArrayRef(getCounter(Data->CounterPtr),
182                                 swap(Data->NumCounters));
183 
184   // Check bounds.
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);
191 
192   // Store the data in Record, byte-swapping as necessary.
193   Record.Hash = swap(Data->FuncHash);
194   Record.Name = RawName;
195   if (ShouldSwapBytes) {
196     Counts.clear();
197     Counts.reserve(RawCounts.size());
198     for (uint64_t Count : RawCounts)
199       Counts.push_back(swap(Count));
200     Record.Counts = Counts;
201   } else
202     Record.Counts = RawCounts;
203 
204   // Iterate.
205   ++Data;
206   return success();
207 }
208 
209 namespace llvm {
210 template class RawInstrProfReader<uint32_t>;
211 template class RawInstrProfReader<uint64_t>;
212 }
213