mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-22 10:29:35 +00:00
Summary: As discussed in http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20141027/242445.html, the creation of reader and writer instances is better done using ErrorOr. There are no functional changes, but several callers needed to be adjusted. Reviewers: bogner Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D6076 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@221120 91177308-0d34-0410-b5e6-96231b3b80d8
400 lines
15 KiB
C++
400 lines
15 KiB
C++
//===- SampleProfReader.cpp - Read LLVM sample profile data ---------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the class that reads LLVM sample profiles. It
|
|
// supports two file formats: text and binary. The textual representation
|
|
// is useful for debugging and testing purposes. The binary representation
|
|
// is more compact, resulting in smaller file sizes. However, they can
|
|
// both be used interchangeably.
|
|
//
|
|
// NOTE: If you are making changes to the file format, please remember
|
|
// to document them in the Clang documentation at
|
|
// tools/clang/docs/UsersManual.rst.
|
|
//
|
|
// Text format
|
|
// -----------
|
|
//
|
|
// Sample profiles are written as ASCII text. The file is divided into
|
|
// sections, which correspond to each of the functions executed at runtime.
|
|
// Each section has the following format
|
|
//
|
|
// function1:total_samples:total_head_samples
|
|
// offset1[.discriminator]: number_of_samples [fn1:num fn2:num ... ]
|
|
// offset2[.discriminator]: number_of_samples [fn3:num fn4:num ... ]
|
|
// ...
|
|
// offsetN[.discriminator]: number_of_samples [fn5:num fn6:num ... ]
|
|
//
|
|
// The file may contain blank lines between sections and within a
|
|
// section. However, the spacing within a single line is fixed. Additional
|
|
// spaces will result in an error while reading the file.
|
|
//
|
|
// Function names must be mangled in order for the profile loader to
|
|
// match them in the current translation unit. The two numbers in the
|
|
// function header specify how many total samples were accumulated in the
|
|
// function (first number), and the total number of samples accumulated
|
|
// in the prologue of the function (second number). This head sample
|
|
// count provides an indicator of how frequently the function is invoked.
|
|
//
|
|
// Each sampled line may contain several items. Some are optional (marked
|
|
// below):
|
|
//
|
|
// a. Source line offset. This number represents the line number
|
|
// in the function where the sample was collected. The line number is
|
|
// always relative to the line where symbol of the function is
|
|
// defined. So, if the function has its header at line 280, the offset
|
|
// 13 is at line 293 in the file.
|
|
//
|
|
// Note that this offset should never be a negative number. This could
|
|
// happen in cases like macros. The debug machinery will register the
|
|
// line number at the point of macro expansion. So, if the macro was
|
|
// expanded in a line before the start of the function, the profile
|
|
// converter should emit a 0 as the offset (this means that the optimizers
|
|
// will not be able to associate a meaningful weight to the instructions
|
|
// in the macro).
|
|
//
|
|
// b. [OPTIONAL] Discriminator. This is used if the sampled program
|
|
// was compiled with DWARF discriminator support
|
|
// (http://wiki.dwarfstd.org/index.php?title=Path_Discriminators).
|
|
// DWARF discriminators are unsigned integer values that allow the
|
|
// compiler to distinguish between multiple execution paths on the
|
|
// same source line location.
|
|
//
|
|
// For example, consider the line of code ``if (cond) foo(); else bar();``.
|
|
// If the predicate ``cond`` is true 80% of the time, then the edge
|
|
// into function ``foo`` should be considered to be taken most of the
|
|
// time. But both calls to ``foo`` and ``bar`` are at the same source
|
|
// line, so a sample count at that line is not sufficient. The
|
|
// compiler needs to know which part of that line is taken more
|
|
// frequently.
|
|
//
|
|
// This is what discriminators provide. In this case, the calls to
|
|
// ``foo`` and ``bar`` will be at the same line, but will have
|
|
// different discriminator values. This allows the compiler to correctly
|
|
// set edge weights into ``foo`` and ``bar``.
|
|
//
|
|
// c. Number of samples. This is an integer quantity representing the
|
|
// number of samples collected by the profiler at this source
|
|
// location.
|
|
//
|
|
// d. [OPTIONAL] Potential call targets and samples. If present, this
|
|
// line contains a call instruction. This models both direct and
|
|
// number of samples. For example,
|
|
//
|
|
// 130: 7 foo:3 bar:2 baz:7
|
|
//
|
|
// The above means that at relative line offset 130 there is a call
|
|
// instruction that calls one of ``foo()``, ``bar()`` and ``baz()``,
|
|
// with ``baz()`` being the relatively more frequently called target.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#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;
|
|
|
|
/// \brief Print the samples collected for a function on stream \p OS.
|
|
///
|
|
/// \param OS Stream to emit the output to.
|
|
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";
|
|
}
|
|
|
|
/// \brief Dump the function profile for \p FName.
|
|
///
|
|
/// \param FName Name of the function to print.
|
|
/// \param OS Stream to emit the output to.
|
|
void SampleProfileReader::dumpFunctionProfile(StringRef FName,
|
|
raw_ostream &OS) {
|
|
OS << "Function: " << FName << ": ";
|
|
Profiles[FName].print(OS);
|
|
}
|
|
|
|
/// \brief Dump all the function profiles found on stream \p OS.
|
|
void SampleProfileReader::dump(raw_ostream &OS) {
|
|
for (const auto &I : Profiles)
|
|
dumpFunctionProfile(I.getKey(), OS);
|
|
}
|
|
|
|
/// \brief Load samples from a text file.
|
|
///
|
|
/// See the documentation at the top of the file for an explanation of
|
|
/// the expected format.
|
|
///
|
|
/// \returns true if the file was loaded successfully, false otherwise.
|
|
std::error_code SampleProfileReaderText::read() {
|
|
line_iterator LineIt(*Buffer, /*SkipBlanks=*/true, '#');
|
|
|
|
// Read the profile of each function. Since each function may be
|
|
// mentioned more than once, and we are collecting flat profiles,
|
|
// accumulate samples as we parse them.
|
|
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()) {
|
|
// Read the header of each function.
|
|
//
|
|
// Note that for function identifiers we are actually expecting
|
|
// mangled names, but we may not always get them. This happens when
|
|
// the compiler decides not to emit the function (e.g., it was inlined
|
|
// and removed). In this case, the binary will not have the linkage
|
|
// name for the function, so the profiler will emit the function's
|
|
// unmangled name, which may contain characters like ':' and '>' in its
|
|
// name (member functions, templates, etc).
|
|
//
|
|
// The only requirement we place on the identifier, then, is that it
|
|
// should not begin with a number.
|
|
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;
|
|
|
|
// Now read the body. The body of the function ends when we reach
|
|
// EOF or when we see the start of the next function.
|
|
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);
|
|
|
|
// If there are function calls in this line, generate a call sample
|
|
// entry for each call.
|
|
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);
|
|
|
|
// Read the samples in the body.
|
|
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();
|
|
|
|
// Read and check the magic identifier.
|
|
auto Magic = readNumber<uint64_t>();
|
|
if (std::error_code EC = Magic.getError())
|
|
return EC;
|
|
else if (*Magic != SPMagic())
|
|
return sampleprof_error::bad_magic;
|
|
|
|
// Read the version number.
|
|
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();
|
|
}
|
|
|
|
/// \brief Prepare a memory buffer for the contents of \p Filename.
|
|
///
|
|
/// \returns an error code indicating the status of the buffer.
|
|
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());
|
|
|
|
// Sanity check the file.
|
|
if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
|
|
return sampleprof_error::too_large;
|
|
|
|
return std::move(Buffer);
|
|
}
|
|
|
|
/// \brief Create a sample profile reader based on the format of the input file.
|
|
///
|
|
/// \param Filename The file to open.
|
|
///
|
|
/// \param Reader The reader to instantiate according to \p Filename's format.
|
|
///
|
|
/// \param C The LLVM context to use to emit diagnostics.
|
|
///
|
|
/// \returns an error code indicating the status of the created reader.
|
|
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);
|
|
}
|