return instrprof_error::too_large;
// Create the reader.
- if (RawInstrProfReader::hasFormat(*Buffer))
- Result.reset(new RawInstrProfReader(std::move(Buffer)));
+ if (RawInstrProfReader64::hasFormat(*Buffer))
+ Result.reset(new RawInstrProfReader64(std::move(Buffer)));
+ else if (RawInstrProfReader32::hasFormat(*Buffer))
+ Result.reset(new RawInstrProfReader32(std::move(Buffer)));
else
Result.reset(new TextInstrProfReader(std::move(Buffer)));
return success();
}
-RawInstrProfReader::RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
- : DataBuffer(std::move(DataBuffer)) { }
+template <class IntPtrT>
+static uint64_t getRawMagic();
-static uint64_t getRawMagic() {
+template <>
+uint64_t getRawMagic<uint64_t>() {
return
uint64_t(255) << 56 |
uint64_t('l') << 48 |
uint64_t(129);
}
-bool RawInstrProfReader::hasFormat(const MemoryBuffer &DataBuffer) {
- if (DataBuffer.getBufferSize() < sizeof(getRawMagic()))
+template <>
+uint64_t getRawMagic<uint32_t>() {
+ return
+ uint64_t(255) << 56 |
+ uint64_t('l') << 48 |
+ uint64_t('p') << 40 |
+ uint64_t('r') << 32 |
+ uint64_t('o') << 24 |
+ uint64_t('f') << 16 |
+ uint64_t('R') << 8 |
+ uint64_t(129);
+}
+
+template <class IntPtrT>
+bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
+ if (DataBuffer.getBufferSize() < sizeof(uint64_t))
return false;
- const RawHeader *Header = (const RawHeader *)DataBuffer.getBufferStart();
- return getRawMagic() == Header->Magic ||
- sys::SwapByteOrder(getRawMagic()) == Header->Magic;
+ uint64_t Magic =
+ *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
+ return getRawMagic<IntPtrT>() == Magic ||
+ sys::SwapByteOrder(getRawMagic<IntPtrT>()) == Magic;
}
-error_code RawInstrProfReader::readHeader() {
+template <class IntPtrT>
+error_code RawInstrProfReader<IntPtrT>::readHeader() {
if (!hasFormat(*DataBuffer))
return error(instrprof_error::bad_magic);
if (DataBuffer->getBufferSize() < sizeof(RawHeader))
return error(instrprof_error::bad_header);
- const RawHeader *Header = (const RawHeader *)DataBuffer->getBufferStart();
- ShouldSwapBytes = Header->Magic != getRawMagic();
+ auto *Header =
+ reinterpret_cast<const RawHeader *>(DataBuffer->getBufferStart());
+ ShouldSwapBytes = Header->Magic != getRawMagic<IntPtrT>();
return readHeader(*Header);
}
return 1;
}
-error_code RawInstrProfReader::readHeader(const RawHeader &Header) {
+template <class IntPtrT>
+error_code RawInstrProfReader<IntPtrT>::readHeader(const RawHeader &Header) {
if (swap(Header.Version) != getRawVersion())
return error(instrprof_error::unsupported_version);
if (FileSize != DataBuffer->getBufferSize())
return error(instrprof_error::bad_header);
- Data = (ProfileData *)(DataBuffer->getBufferStart() + DataOffset);
+ const char *Start = DataBuffer->getBufferStart();
+ Data = reinterpret_cast<const ProfileData *>(Start + DataOffset);
DataEnd = Data + DataSize;
- CountersStart = (uint64_t *)(DataBuffer->getBufferStart() + CountersOffset);
- NamesStart = DataBuffer->getBufferStart() + NamesOffset;
+ CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
+ NamesStart = Start + NamesOffset;
return success();
}
-error_code RawInstrProfReader::readNextRecord(InstrProfRecord &Record) {
+template <class IntPtrT>
+error_code
+RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
if (Data == DataEnd)
return error(instrprof_error::eof);
swap(Data->NumCounters));
// Check bounds.
+ auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
if (RawName.data() < NamesStart ||
RawName.data() + RawName.size() > DataBuffer->getBufferEnd() ||
RawCounts.data() < CountersStart ||
- RawCounts.data() + RawCounts.size() > (uint64_t *)NamesStart)
+ RawCounts.data() + RawCounts.size() > NamesStartAsCounter)
return error(instrprof_error::malformed);
// Store the data in Record, byte-swapping as necessary.
++Data;
return success();
}
+
+namespace llvm {
+template class RawInstrProfReader<uint32_t>;
+template class RawInstrProfReader<uint64_t>;
+}