SampleProfReader.cpp [plain text]
#include "llvm/ProfileData/SampleProfReader.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/ErrorOr.h"
#include "llvm/Support/LEB128.h"
#include "llvm/Support/LineIterator.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Regex.h"
using namespace llvm::sampleprof;
using namespace llvm;
void FunctionSamples::print(raw_ostream &OS) {
OS << TotalSamples << ", " << TotalHeadSamples << ", " << BodySamples.size()
<< " sampled lines\n";
for (const auto &SI : BodySamples) {
LineLocation Loc = SI.first;
const SampleRecord &Sample = SI.second;
OS << "\tline offset: " << Loc.LineOffset
<< ", discriminator: " << Loc.Discriminator
<< ", number of samples: " << Sample.getSamples();
if (Sample.hasCalls()) {
OS << ", calls:";
for (const auto &I : Sample.getCallTargets())
OS << " " << I.first() << ":" << I.second;
}
OS << "\n";
}
OS << "\n";
}
void SampleProfileReader::dumpFunctionProfile(StringRef FName,
raw_ostream &OS) {
OS << "Function: " << FName << ": ";
Profiles[FName].print(OS);
}
void SampleProfileReader::dump(raw_ostream &OS) {
for (const auto &I : Profiles)
dumpFunctionProfile(I.getKey(), OS);
}
std::error_code SampleProfileReaderText::read() {
line_iterator LineIt(*Buffer, true, '#');
Regex HeadRE("^([^0-9].*):([0-9]+):([0-9]+)$");
Regex LineSampleRE("^([0-9]+)\\.?([0-9]+)?: ([0-9]+)(.*)$");
Regex CallSampleRE(" +([^0-9 ][^ ]*):([0-9]+)");
while (!LineIt.is_at_eof()) {
SmallVector<StringRef, 4> Matches;
if (!HeadRE.match(*LineIt, &Matches)) {
reportParseError(LineIt.line_number(),
"Expected 'mangled_name:NUM:NUM', found " + *LineIt);
return sampleprof_error::malformed;
}
assert(Matches.size() == 4);
StringRef FName = Matches[1];
unsigned NumSamples, NumHeadSamples;
Matches[2].getAsInteger(10, NumSamples);
Matches[3].getAsInteger(10, NumHeadSamples);
Profiles[FName] = FunctionSamples();
FunctionSamples &FProfile = Profiles[FName];
FProfile.addTotalSamples(NumSamples);
FProfile.addHeadSamples(NumHeadSamples);
++LineIt;
while (!LineIt.is_at_eof() && isdigit((*LineIt)[0])) {
if (!LineSampleRE.match(*LineIt, &Matches)) {
reportParseError(
LineIt.line_number(),
"Expected 'NUM[.NUM]: NUM[ mangled_name:NUM]*', found " + *LineIt);
return sampleprof_error::malformed;
}
assert(Matches.size() == 5);
unsigned LineOffset, NumSamples, Discriminator = 0;
Matches[1].getAsInteger(10, LineOffset);
if (Matches[2] != "")
Matches[2].getAsInteger(10, Discriminator);
Matches[3].getAsInteger(10, NumSamples);
std::string CallsLine(Matches[4]);
while (CallsLine != "") {
SmallVector<StringRef, 3> CallSample;
if (!CallSampleRE.match(CallsLine, &CallSample)) {
reportParseError(LineIt.line_number(),
"Expected 'mangled_name:NUM', found " + CallsLine);
return sampleprof_error::malformed;
}
StringRef CalledFunction = CallSample[1];
unsigned CalledFunctionSamples;
CallSample[2].getAsInteger(10, CalledFunctionSamples);
FProfile.addCalledTargetSamples(LineOffset, Discriminator,
CalledFunction, CalledFunctionSamples);
CallsLine = CallSampleRE.sub("", CallsLine);
}
FProfile.addBodySamples(LineOffset, Discriminator, NumSamples);
++LineIt;
}
}
return sampleprof_error::success;
}
template <typename T> ErrorOr<T> SampleProfileReaderBinary::readNumber() {
unsigned NumBytesRead = 0;
std::error_code EC;
uint64_t Val = decodeULEB128(Data, &NumBytesRead);
if (Val > std::numeric_limits<T>::max())
EC = sampleprof_error::malformed;
else if (Data + NumBytesRead > End)
EC = sampleprof_error::truncated;
else
EC = sampleprof_error::success;
if (EC) {
reportParseError(0, EC.message());
return EC;
}
Data += NumBytesRead;
return static_cast<T>(Val);
}
ErrorOr<StringRef> SampleProfileReaderBinary::readString() {
std::error_code EC;
StringRef Str(reinterpret_cast<const char *>(Data));
if (Data + Str.size() + 1 > End) {
EC = sampleprof_error::truncated;
reportParseError(0, EC.message());
return EC;
}
Data += Str.size() + 1;
return Str;
}
std::error_code SampleProfileReaderBinary::read() {
while (!at_eof()) {
auto FName(readString());
if (std::error_code EC = FName.getError())
return EC;
Profiles[*FName] = FunctionSamples();
FunctionSamples &FProfile = Profiles[*FName];
auto Val = readNumber<unsigned>();
if (std::error_code EC = Val.getError())
return EC;
FProfile.addTotalSamples(*Val);
Val = readNumber<unsigned>();
if (std::error_code EC = Val.getError())
return EC;
FProfile.addHeadSamples(*Val);
auto NumRecords = readNumber<unsigned>();
if (std::error_code EC = NumRecords.getError())
return EC;
for (unsigned I = 0; I < *NumRecords; ++I) {
auto LineOffset = readNumber<uint64_t>();
if (std::error_code EC = LineOffset.getError())
return EC;
auto Discriminator = readNumber<uint64_t>();
if (std::error_code EC = Discriminator.getError())
return EC;
auto NumSamples = readNumber<uint64_t>();
if (std::error_code EC = NumSamples.getError())
return EC;
auto NumCalls = readNumber<unsigned>();
if (std::error_code EC = NumCalls.getError())
return EC;
for (unsigned J = 0; J < *NumCalls; ++J) {
auto CalledFunction(readString());
if (std::error_code EC = CalledFunction.getError())
return EC;
auto CalledFunctionSamples = readNumber<uint64_t>();
if (std::error_code EC = CalledFunctionSamples.getError())
return EC;
FProfile.addCalledTargetSamples(*LineOffset, *Discriminator,
*CalledFunction,
*CalledFunctionSamples);
}
FProfile.addBodySamples(*LineOffset, *Discriminator, *NumSamples);
}
}
return sampleprof_error::success;
}
std::error_code SampleProfileReaderBinary::readHeader() {
Data = reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
End = Data + Buffer->getBufferSize();
auto Magic = readNumber<uint64_t>();
if (std::error_code EC = Magic.getError())
return EC;
else if (*Magic != SPMagic())
return sampleprof_error::bad_magic;
auto Version = readNumber<uint64_t>();
if (std::error_code EC = Version.getError())
return EC;
else if (*Version != SPVersion())
return sampleprof_error::unsupported_version;
return sampleprof_error::success;
}
bool SampleProfileReaderBinary::hasFormat(const MemoryBuffer &Buffer) {
const uint8_t *Data =
reinterpret_cast<const uint8_t *>(Buffer.getBufferStart());
uint64_t Magic = decodeULEB128(Data);
return Magic == SPMagic();
}
static ErrorOr<std::unique_ptr<MemoryBuffer>>
setupMemoryBuffer(std::string Filename) {
auto BufferOrErr = MemoryBuffer::getFileOrSTDIN(Filename);
if (std::error_code EC = BufferOrErr.getError())
return EC;
auto Buffer = std::move(BufferOrErr.get());
if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
return sampleprof_error::too_large;
return std::move(Buffer);
}
ErrorOr<std::unique_ptr<SampleProfileReader>>
SampleProfileReader::create(StringRef Filename, LLVMContext &C) {
auto BufferOrError = setupMemoryBuffer(Filename);
if (std::error_code EC = BufferOrError.getError())
return EC;
auto Buffer = std::move(BufferOrError.get());
std::unique_ptr<SampleProfileReader> Reader;
if (SampleProfileReaderBinary::hasFormat(*Buffer))
Reader.reset(new SampleProfileReaderBinary(std::move(Buffer), C));
else
Reader.reset(new SampleProfileReaderText(std::move(Buffer), C));
if (std::error_code EC = Reader->readHeader())
return EC;
return std::move(Reader);
}