#include "llvm/Support/Debug.h"
#include "llvm/Support/Endian.h"
#include "llvm/Support/LEB128.h"
+#include "llvm/Support/MathExtras.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
std::error_code RawCoverageReader::readULEB128(uint64_t &Result) {
if (Data.size() < 1)
- return error(instrprof_error::truncated);
+ return coveragemap_error::truncated;
unsigned N = 0;
Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
if (N > Data.size())
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
Data = Data.substr(N);
- return success();
+ return std::error_code();
}
std::error_code RawCoverageReader::readIntMax(uint64_t &Result,
if (auto Err = readULEB128(Result))
return Err;
if (Result >= MaxPlus1)
- return error(instrprof_error::malformed);
- return success();
+ return coveragemap_error::malformed;
+ return std::error_code();
}
std::error_code RawCoverageReader::readSize(uint64_t &Result) {
return Err;
// Sanity check the number.
if (Result > Data.size())
- return error(instrprof_error::malformed);
- return success();
+ return coveragemap_error::malformed;
+ return std::error_code();
}
std::error_code RawCoverageReader::readString(StringRef &Result) {
return Err;
Result = Data.substr(0, Length);
Data = Data.substr(Length);
- return success();
+ return std::error_code();
}
std::error_code RawCoverageFilenamesReader::read() {
return Err;
Filenames.push_back(Filename);
}
- return success();
+ return std::error_code();
}
std::error_code RawCoverageMappingReader::decodeCounter(unsigned Value,
switch (Tag) {
case Counter::Zero:
C = Counter::getZero();
- return success();
+ return std::error_code();
case Counter::CounterValueReference:
C = Counter::getCounter(Value >> Counter::EncodingTagBits);
- return success();
+ return std::error_code();
default:
break;
}
case CounterExpression::Add: {
auto ID = Value >> Counter::EncodingTagBits;
if (ID >= Expressions.size())
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
C = Counter::getExpression(ID);
break;
}
default:
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
}
- return success();
+ return std::error_code();
}
std::error_code RawCoverageMappingReader::readCounter(Counter &C) {
return Err;
if (auto Err = decodeCounter(EncodedCounter, C))
return Err;
- return success();
+ return std::error_code();
}
static const unsigned EncodingExpansionRegionBit = 1
ExpandedFileID = EncodedCounterAndRegion >>
Counter::EncodingCounterTagAndExpansionRegionTagBits;
if (ExpandedFileID >= NumFileIDs)
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
} else {
switch (EncodedCounterAndRegion >>
Counter::EncodingCounterTagAndExpansionRegionTagBits) {
Kind = CounterMappingRegion::SkippedRegion;
break;
default:
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
}
}
}
if (auto Err = readULEB128(ColumnStart))
return Err;
if (ColumnStart > std::numeric_limits<unsigned>::max())
- return error(instrprof_error::malformed);
+ return coveragemap_error::malformed;
if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max()))
return Err;
if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max()))
C, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
LineStart + NumLines, ColumnEnd, Kind));
}
- return success();
+ return std::error_code();
}
std::error_code RawCoverageMappingReader::read() {
}
}
- return success();
+ return std::error_code();
}
namespace {
if (auto Err = Section.getContents(Data))
return Err;
Address = Section.getAddress();
- return instrprof_error::success;
+ return std::error_code();
}
std::error_code get(uint64_t Pointer, size_t Size, StringRef &Result) {
if (Pointer < Address)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
auto Offset = Pointer - Address;
if (Offset + Size > Data.size())
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
Result = Data.substr(Pointer - Address, Size);
- return instrprof_error::success;
+ return std::error_code();
}
};
}
// Read the records in the coverage data section.
for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
if (Buf + 4 * sizeof(uint32_t) > End)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
uint32_t NRecords = endian::readNext<uint32_t, Endian, unaligned>(Buf);
uint32_t FilenamesSize = endian::readNext<uint32_t, Endian, unaligned>(Buf);
uint32_t CoverageSize = endian::readNext<uint32_t, Endian, unaligned>(Buf);
case CoverageMappingVersion1:
break;
default:
- return instrprof_error::unsupported_version;
+ return coveragemap_error::unsupported_version;
}
// Skip past the function records, saving the start and end for later.
// Get the filenames.
if (Buf + FilenamesSize > End)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
size_t FilenamesBegin = Filenames.size();
RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
if (auto Err = Reader.read())
const char *CovBuf = Buf;
Buf += CoverageSize;
const char *CovEnd = Buf;
+
if (Buf > End)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
+ // Each coverage map has an alignment of 8, so we need to adjust alignment
+ // before reading the next map.
+ Buf += alignmentAdjustment(Buf, 8);
while (FunBuf < FunEnd) {
// Read the function information
// Now use that to read the coverage data.
if (CovBuf + DataSize > CovEnd)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
auto Mapping = StringRef(CovBuf, DataSize);
CovBuf += DataSize;
}
}
- return instrprof_error::success;
+ return std::error_code();
}
static const char *TestingFormatMagic = "llvmcovmtestdata";
Data = Data.substr(StringRef(TestingFormatMagic).size());
if (Data.size() < 1)
- return instrprof_error::truncated;
+ return coveragemap_error::truncated;
unsigned N = 0;
auto ProfileNamesSize =
decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
if (N > Data.size())
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
Data = Data.substr(N);
if (Data.size() < 1)
- return instrprof_error::truncated;
+ return coveragemap_error::truncated;
N = 0;
ProfileNames.Address =
decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
if (N > Data.size())
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
Data = Data.substr(N);
if (Data.size() < ProfileNamesSize)
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
ProfileNames.Data = Data.substr(0, ProfileNamesSize);
CoverageMapping = Data.substr(ProfileNamesSize);
- return instrprof_error::success;
+ return std::error_code();
+}
+
+static ErrorOr<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
+ StringRef FoundName;
+ for (const auto &Section : OF.sections()) {
+ if (auto EC = Section.getName(FoundName))
+ return EC;
+ if (FoundName == Name)
+ return Section;
+ }
+ return coveragemap_error::no_data_found;
}
static std::error_code loadBinaryFormat(MemoryBufferRef ObjectBuffer,
return object_error::arch_not_found;
} else
// We can only handle object files.
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
// The coverage uses native pointer sizes for the object it's written in.
BytesInAddress = OF->getBytesInAddress();
: support::endianness::big;
// Look for the sections that we are interested in.
- int FoundSectionCount = 0;
- SectionRef NamesSection, CoverageSection;
- for (const auto &Section : OF->sections()) {
- StringRef Name;
- if (auto Err = Section.getName(Name))
- return Err;
- if (Name == "__llvm_prf_names") {
- NamesSection = Section;
- } else if (Name == "__llvm_covmap") {
- CoverageSection = Section;
- } else
- continue;
- ++FoundSectionCount;
- }
- if (FoundSectionCount != 2)
- return instrprof_error::bad_header;
+ auto NamesSection = lookupSection(*OF, "__llvm_prf_names");
+ if (auto EC = NamesSection.getError())
+ return EC;
+ auto CoverageSection = lookupSection(*OF, "__llvm_covmap");
+ if (auto EC = CoverageSection.getError())
+ return EC;
// Get the contents of the given sections.
- if (std::error_code EC = CoverageSection.getContents(CoverageMapping))
+ if (std::error_code EC = CoverageSection->getContents(CoverageMapping))
return EC;
- if (std::error_code EC = ProfileNames.load(NamesSection))
+ if (std::error_code EC = ProfileNames.load(*NamesSection))
return EC;
return std::error_code();
EC = readCoverageMappingData<uint64_t, support::endianness::big>(
Profile, Coverage, Reader->MappingRecords, Reader->Filenames);
else
- return instrprof_error::malformed;
+ return coveragemap_error::malformed;
if (EC)
return EC;
return std::move(Reader);
std::error_code
BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
if (CurrentRecord >= MappingRecords.size())
- return instrprof_error::eof;
+ return coveragemap_error::eof;
FunctionsFilenames.clear();
Expressions.clear();
OSDN Git Service
