diff options
Diffstat (limited to 'llvm/lib/ProfileData/Coverage')
| -rw-r--r-- | llvm/lib/ProfileData/Coverage/CoverageMapping.cpp | 86 | ||||
| -rw-r--r-- | llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp | 230 |
2 files changed, 150 insertions, 166 deletions
diff --git a/llvm/lib/ProfileData/Coverage/CoverageMapping.cpp b/llvm/lib/ProfileData/Coverage/CoverageMapping.cpp index 7133697bb87..9fdd37081c9 100644 --- a/llvm/lib/ProfileData/Coverage/CoverageMapping.cpp +++ b/llvm/lib/ProfileData/Coverage/CoverageMapping.cpp @@ -143,30 +143,28 @@ void CounterMappingContext::dump(const Counter &C, } if (CounterValues.empty()) return; - Expected<int64_t> Value = evaluate(C); - if (auto E = Value.takeError()) { - llvm::consumeError(std::move(E)); + ErrorOr<int64_t> Value = evaluate(C); + if (!Value) return; - } OS << '[' << *Value << ']'; } -Expected<int64_t> CounterMappingContext::evaluate(const Counter &C) const { +ErrorOr<int64_t> CounterMappingContext::evaluate(const Counter &C) const { switch (C.getKind()) { case Counter::Zero: return 0; case Counter::CounterValueReference: if (C.getCounterID() >= CounterValues.size()) - return errorCodeToError(errc::argument_out_of_domain); + return make_error_code(errc::argument_out_of_domain); return CounterValues[C.getCounterID()]; case Counter::Expression: { if (C.getExpressionID() >= Expressions.size()) - return errorCodeToError(errc::argument_out_of_domain); + return make_error_code(errc::argument_out_of_domain); const auto &E = Expressions[C.getExpressionID()]; - Expected<int64_t> LHS = evaluate(E.LHS); + ErrorOr<int64_t> LHS = evaluate(E.LHS); if (!LHS) return LHS; - Expected<int64_t> RHS = evaluate(E.RHS); + ErrorOr<int64_t> RHS = evaluate(E.RHS); if (!RHS) return RHS; return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS; @@ -183,7 +181,7 @@ void FunctionRecordIterator::skipOtherFiles() { *this = FunctionRecordIterator(); } -Expected<std::unique_ptr<CoverageMapping>> +ErrorOr<std::unique_ptr<CoverageMapping>> CoverageMapping::load(CoverageMappingReader &CoverageReader, IndexedInstrProfReader &ProfileReader) { auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping()); @@ -193,14 +191,13 @@ CoverageMapping::load(CoverageMappingReader &CoverageReader, CounterMappingContext Ctx(Record.Expressions); Counts.clear(); - if (Error E = ProfileReader.getFunctionCounts( + if (std::error_code EC = ProfileReader.getFunctionCounts( Record.FunctionName, Record.FunctionHash, Counts)) { - instrprof_error IPE = InstrProfError::take(std::move(E)); - if (IPE == instrprof_error::hash_mismatch) { + if (EC == instrprof_error::hash_mismatch) { Coverage->MismatchedFunctionCount++; continue; - } else if (IPE != instrprof_error::unknown_function) - return make_error<InstrProfError>(IPE); + } else if (EC != instrprof_error::unknown_function) + return EC; Counts.assign(Record.MappingRegions.size(), 0); } Ctx.setCounts(Counts); @@ -215,11 +212,9 @@ CoverageMapping::load(CoverageMappingReader &CoverageReader, getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]); FunctionRecord Function(OrigFuncName, Record.Filenames); for (const auto &Region : Record.MappingRegions) { - Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count); - if (auto E = ExecutionCount.takeError()) { - llvm::consumeError(std::move(E)); + ErrorOr<int64_t> ExecutionCount = Ctx.evaluate(Region.Count); + if (!ExecutionCount) break; - } Function.pushRegion(Region, *ExecutionCount); } if (Function.CountedRegions.size() != Record.MappingRegions.size()) { @@ -233,20 +228,20 @@ CoverageMapping::load(CoverageMappingReader &CoverageReader, return std::move(Coverage); } -Expected<std::unique_ptr<CoverageMapping>> +ErrorOr<std::unique_ptr<CoverageMapping>> CoverageMapping::load(StringRef ObjectFilename, StringRef ProfileFilename, StringRef Arch) { auto CounterMappingBuff = MemoryBuffer::getFileOrSTDIN(ObjectFilename); if (std::error_code EC = CounterMappingBuff.getError()) - return errorCodeToError(EC); + return EC; auto CoverageReaderOrErr = BinaryCoverageReader::create(CounterMappingBuff.get(), Arch); - if (Error E = CoverageReaderOrErr.takeError()) - return std::move(E); + if (std::error_code EC = CoverageReaderOrErr.getError()) + return EC; auto CoverageReader = std::move(CoverageReaderOrErr.get()); auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename); - if (Error E = ProfileReaderOrErr.takeError()) - return std::move(E); + if (auto EC = ProfileReaderOrErr.getError()) + return EC; auto ProfileReader = std::move(ProfileReaderOrErr.get()); return load(*CoverageReader, *ProfileReader); } @@ -538,34 +533,27 @@ CoverageMapping::getCoverageForExpansion(const ExpansionRecord &Expansion) { } namespace { -std::string getCoverageMapErrString(coveragemap_error Err) { - switch (Err) { - case coveragemap_error::success: - return "Success"; - case coveragemap_error::eof: - return "End of File"; - case coveragemap_error::no_data_found: - return "No coverage data found"; - case coveragemap_error::unsupported_version: - return "Unsupported coverage format version"; - case coveragemap_error::truncated: - return "Truncated coverage data"; - case coveragemap_error::malformed: - return "Malformed coverage data"; - } - llvm_unreachable("A value of coveragemap_error has no message."); -} - class CoverageMappingErrorCategoryType : public std::error_category { const char *name() const LLVM_NOEXCEPT override { return "llvm.coveragemap"; } std::string message(int IE) const override { - return getCoverageMapErrString(static_cast<coveragemap_error>(IE)); + auto E = static_cast<coveragemap_error>(IE); + switch (E) { + case coveragemap_error::success: + return "Success"; + case coveragemap_error::eof: + return "End of File"; + case coveragemap_error::no_data_found: + return "No coverage data found"; + case coveragemap_error::unsupported_version: + return "Unsupported coverage format version"; + case coveragemap_error::truncated: + return "Truncated coverage data"; + case coveragemap_error::malformed: + return "Malformed coverage data"; + } + llvm_unreachable("A value of coveragemap_error has no message."); } }; -} // end anonymous namespace - -std::string CoverageMapError::message() const { - return getCoverageMapErrString(Err); } static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory; @@ -573,5 +561,3 @@ static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory; const std::error_category &llvm::coverage::coveragemap_category() { return *ErrorCategory; } - -template <> char ProfErrorInfoBase<coveragemap_error>::ID = 0; diff --git a/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp b/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp index 999460dd5a8..9f27de91bc5 100644 --- a/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp +++ b/llvm/lib/ProfileData/Coverage/CoverageMappingReader.cpp @@ -31,54 +31,49 @@ using namespace object; void CoverageMappingIterator::increment() { // Check if all the records were read or if an error occurred while reading // the next record. - if (auto E = Reader->readNextRecord(Record)) { - handleAllErrors(std::move(E), [&](const CoverageMapError &CME) { - if (CME.get() == coveragemap_error::eof) - *this = CoverageMappingIterator(); - else - llvm_unreachable("Unexpected error in coverage mapping iterator"); - }); - } + if (Reader->readNextRecord(Record)) + *this = CoverageMappingIterator(); } -Error RawCoverageReader::readULEB128(uint64_t &Result) { +std::error_code RawCoverageReader::readULEB128(uint64_t &Result) { if (Data.size() < 1) - return make_error<CoverageMapError>(coveragemap_error::truncated); + return coveragemap_error::truncated; unsigned N = 0; Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N); if (N > Data.size()) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; Data = Data.substr(N); - return Error::success(); + return std::error_code(); } -Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) { +std::error_code RawCoverageReader::readIntMax(uint64_t &Result, + uint64_t MaxPlus1) { if (auto Err = readULEB128(Result)) return Err; if (Result >= MaxPlus1) - return make_error<CoverageMapError>(coveragemap_error::malformed); - return Error::success(); + return coveragemap_error::malformed; + return std::error_code(); } -Error RawCoverageReader::readSize(uint64_t &Result) { +std::error_code RawCoverageReader::readSize(uint64_t &Result) { if (auto Err = readULEB128(Result)) return Err; // Sanity check the number. if (Result > Data.size()) - return make_error<CoverageMapError>(coveragemap_error::malformed); - return Error::success(); + return coveragemap_error::malformed; + return std::error_code(); } -Error RawCoverageReader::readString(StringRef &Result) { +std::error_code RawCoverageReader::readString(StringRef &Result) { uint64_t Length; if (auto Err = readSize(Length)) return Err; Result = Data.substr(0, Length); Data = Data.substr(Length); - return Error::success(); + return std::error_code(); } -Error RawCoverageFilenamesReader::read() { +std::error_code RawCoverageFilenamesReader::read() { uint64_t NumFilenames; if (auto Err = readSize(NumFilenames)) return Err; @@ -88,18 +83,19 @@ Error RawCoverageFilenamesReader::read() { return Err; Filenames.push_back(Filename); } - return Error::success(); + return std::error_code(); } -Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) { +std::error_code RawCoverageMappingReader::decodeCounter(unsigned Value, + Counter &C) { auto Tag = Value & Counter::EncodingTagMask; switch (Tag) { case Counter::Zero: C = Counter::getZero(); - return Error::success(); + return std::error_code(); case Counter::CounterValueReference: C = Counter::getCounter(Value >> Counter::EncodingTagBits); - return Error::success(); + return std::error_code(); default: break; } @@ -109,25 +105,25 @@ Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) { case CounterExpression::Add: { auto ID = Value >> Counter::EncodingTagBits; if (ID >= Expressions.size()) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; Expressions[ID].Kind = CounterExpression::ExprKind(Tag); C = Counter::getExpression(ID); break; } default: - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; } - return Error::success(); + return std::error_code(); } -Error RawCoverageMappingReader::readCounter(Counter &C) { +std::error_code RawCoverageMappingReader::readCounter(Counter &C) { uint64_t EncodedCounter; if (auto Err = readIntMax(EncodedCounter, std::numeric_limits<unsigned>::max())) return Err; if (auto Err = decodeCounter(EncodedCounter, C)) return Err; - return Error::success(); + return std::error_code(); } static const unsigned EncodingExpansionRegionBit = 1 @@ -136,7 +132,7 @@ static const unsigned EncodingExpansionRegionBit = 1 /// \brief Read the sub-array of regions for the given inferred file id. /// \param NumFileIDs the number of file ids that are defined for this /// function. -Error RawCoverageMappingReader::readMappingRegionsSubArray( +std::error_code RawCoverageMappingReader::readMappingRegionsSubArray( std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID, size_t NumFileIDs) { uint64_t NumRegions; @@ -164,7 +160,7 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray( ExpandedFileID = EncodedCounterAndRegion >> Counter::EncodingCounterTagAndExpansionRegionTagBits; if (ExpandedFileID >= NumFileIDs) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; } else { switch (EncodedCounterAndRegion >> Counter::EncodingCounterTagAndExpansionRegionTagBits) { @@ -175,7 +171,7 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray( Kind = CounterMappingRegion::SkippedRegion; break; default: - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; } } } @@ -188,7 +184,7 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray( if (auto Err = readULEB128(ColumnStart)) return Err; if (ColumnStart > std::numeric_limits<unsigned>::max()) - return make_error<CoverageMapError>(coveragemap_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())) @@ -222,10 +218,10 @@ Error RawCoverageMappingReader::readMappingRegionsSubArray( C, InferredFileID, ExpandedFileID, LineStart, ColumnStart, LineStart + NumLines, ColumnEnd, Kind)); } - return Error::success(); + return std::error_code(); } -Error RawCoverageMappingReader::read() { +std::error_code RawCoverageMappingReader::read() { // Read the virtual file mapping. llvm::SmallVector<unsigned, 8> VirtualFileMapping; @@ -291,14 +287,14 @@ Error RawCoverageMappingReader::read() { } } - return Error::success(); + return std::error_code(); } -Error InstrProfSymtab::create(SectionRef &Section) { - if (auto EC = Section.getContents(Data)) - return errorCodeToError(EC); +std::error_code InstrProfSymtab::create(SectionRef &Section) { + if (auto Err = Section.getContents(Data)) + return Err; Address = Section.getAddress(); - return Error::success(); + return std::error_code(); } StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) { @@ -316,10 +312,11 @@ struct CovMapFuncRecordReader { // a module. \p Buf is a reference to the buffer pointer pointing // to the \c CovHeader of coverage mapping data associated with // the module. - virtual Error readFunctionRecords(const char *&Buf, const char *End) = 0; + virtual std::error_code readFunctionRecords(const char *&Buf, + const char *End) = 0; virtual ~CovMapFuncRecordReader() {} template <class IntPtrT, support::endianness Endian> - static Expected<std::unique_ptr<CovMapFuncRecordReader>> + static ErrorOr<std::unique_ptr<CovMapFuncRecordReader>> get(coverage::CovMapVersion Version, InstrProfSymtab &P, std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, std::vector<StringRef> &F); @@ -347,10 +344,11 @@ public: : ProfileNames(P), Filenames(F), Records(R) {} ~VersionedCovMapFuncRecordReader() override {} - Error readFunctionRecords(const char *&Buf, const char *End) override { + std::error_code readFunctionRecords(const char *&Buf, + const char *End) override { using namespace support; if (Buf + sizeof(CovMapHeader) > End) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; auto CovHeader = reinterpret_cast<const coverage::CovMapHeader *>(Buf); uint32_t NRecords = CovHeader->getNRecords<Endian>(); uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>(); @@ -365,7 +363,7 @@ public: // Get the filenames. if (Buf + FilenamesSize > End) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; size_t FilenamesBegin = Filenames.size(); RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames); if (auto Err = Reader.read()) @@ -378,7 +376,7 @@ public: const char *CovEnd = Buf; if (Buf > End) - return make_error<CoverageMapError>(coveragemap_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); @@ -391,7 +389,7 @@ public: // Now use that to read the coverage data. if (CovBuf + DataSize > CovEnd) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; auto Mapping = StringRef(CovBuf, DataSize); CovBuf += DataSize; @@ -405,20 +403,21 @@ public: } StringRef FuncName; - if (Error E = CFR->template getFuncName<Endian>(ProfileNames, FuncName)) - return E; + if (std::error_code EC = + CFR->template getFuncName<Endian>(ProfileNames, FuncName)) + return EC; Records.push_back(BinaryCoverageReader::ProfileMappingRecord( Version, FuncName, FuncHash, Mapping, FilenamesBegin, Filenames.size() - FilenamesBegin)); CFR++; } - return Error::success(); + return std::error_code(); } }; } // end anonymous namespace template <class IntPtrT, support::endianness Endian> -Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get( +ErrorOr<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get( coverage::CovMapVersion Version, InstrProfSymtab &P, std::vector<BinaryCoverageReader::ProfileMappingRecord> &R, std::vector<StringRef> &F) { @@ -429,8 +428,8 @@ Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get( CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F); case CovMapVersion::Version2: // Decompress the name data. - if (Error E = P.create(P.getNameData())) - return std::move(E); + if (auto EC = P.create(P.getNameData())) + return EC; return llvm::make_unique<VersionedCovMapFuncRecordReader< CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F); } @@ -438,7 +437,7 @@ Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get( } template <typename T, support::endianness Endian> -static Error readCoverageMappingData( +static std::error_code readCoverageMappingData( InstrProfSymtab &ProfileNames, StringRef Data, std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records, std::vector<StringRef> &Filenames) { @@ -448,90 +447,89 @@ static Error readCoverageMappingData( reinterpret_cast<const coverage::CovMapHeader *>(Data.data()); CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>(); if (Version > coverage::CovMapVersion::CurrentVersion) - return make_error<CoverageMapError>(coveragemap_error::unsupported_version); - Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected = + return coveragemap_error::unsupported_version; + ErrorOr<std::unique_ptr<CovMapFuncRecordReader>> ReaderErrorOr = CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records, Filenames); - if (Error E = ReaderExpected.takeError()) - return E; - auto Reader = std::move(ReaderExpected.get()); + if (auto EC = ReaderErrorOr.getError()) + return EC; + auto Reader = std::move(ReaderErrorOr.get()); for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) { - if (Error E = Reader->readFunctionRecords(Buf, End)) - return E; + if (std::error_code EC = Reader->readFunctionRecords(Buf, End)) + return EC; } - return Error::success(); + return std::error_code(); } static const char *TestingFormatMagic = "llvmcovmtestdata"; -static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames, - StringRef &CoverageMapping, - uint8_t &BytesInAddress, - support::endianness &Endian) { +static std::error_code loadTestingFormat(StringRef Data, + InstrProfSymtab &ProfileNames, + StringRef &CoverageMapping, + uint8_t &BytesInAddress, + support::endianness &Endian) { BytesInAddress = 8; Endian = support::endianness::little; Data = Data.substr(StringRef(TestingFormatMagic).size()); if (Data.size() < 1) - return make_error<CoverageMapError>(coveragemap_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 make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; Data = Data.substr(N); if (Data.size() < 1) - return make_error<CoverageMapError>(coveragemap_error::truncated); + return coveragemap_error::truncated; N = 0; uint64_t Address = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N); if (N > Data.size()) - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; Data = Data.substr(N); if (Data.size() < ProfileNamesSize) - return make_error<CoverageMapError>(coveragemap_error::malformed); - if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize), Address)) - return E; + return coveragemap_error::malformed; + ProfileNames.create(Data.substr(0, ProfileNamesSize), Address); CoverageMapping = Data.substr(ProfileNamesSize); - return Error::success(); + return std::error_code(); } -static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) { +static ErrorOr<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) { StringRef FoundName; for (const auto &Section : OF.sections()) { if (auto EC = Section.getName(FoundName)) - return errorCodeToError(EC); + return EC; if (FoundName == Name) return Section; } - return make_error<CoverageMapError>(coveragemap_error::no_data_found); + return coveragemap_error::no_data_found; } -static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer, - InstrProfSymtab &ProfileNames, - StringRef &CoverageMapping, - uint8_t &BytesInAddress, - support::endianness &Endian, StringRef Arch) { +static std::error_code +loadBinaryFormat(MemoryBufferRef ObjectBuffer, InstrProfSymtab &ProfileNames, + StringRef &CoverageMapping, uint8_t &BytesInAddress, + support::endianness &Endian, StringRef Arch) { auto BinOrErr = object::createBinary(ObjectBuffer); if (!BinOrErr) - return BinOrErr.takeError(); + return errorToErrorCode(BinOrErr.takeError()); auto Bin = std::move(BinOrErr.get()); std::unique_ptr<ObjectFile> OF; if (auto *Universal = dyn_cast<object::MachOUniversalBinary>(Bin.get())) { // If we have a universal binary, try to look up the object for the // appropriate architecture. auto ObjectFileOrErr = Universal->getObjectForArch(Arch); - if (auto EC = ObjectFileOrErr.getError()) - return errorCodeToError(EC); + if (std::error_code EC = ObjectFileOrErr.getError()) + return EC; OF = std::move(ObjectFileOrErr.get()); } else if (isa<object::ObjectFile>(Bin.get())) { // For any other object file, upcast and take ownership. OF.reset(cast<object::ObjectFile>(Bin.release())); // If we've asked for a particular arch, make sure they match. if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch()) - return errorCodeToError(object_error::arch_not_found); + return object_error::arch_not_found; } else // We can only handle object files. - return make_error<CoverageMapError>(coveragemap_error::malformed); + return coveragemap_error::malformed; // The coverage uses native pointer sizes for the object it's written in. BytesInAddress = OF->getBytesInAddress(); @@ -540,23 +538,23 @@ static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer, // Look for the sections that we are interested in. auto NamesSection = lookupSection(*OF, getInstrProfNameSectionName(false)); - if (auto E = NamesSection.takeError()) - return E; + if (auto EC = NamesSection.getError()) + return EC; auto CoverageSection = lookupSection(*OF, getInstrProfCoverageSectionName(false)); - if (auto E = CoverageSection.takeError()) - return E; + if (auto EC = CoverageSection.getError()) + return EC; // Get the contents of the given sections. - if (auto EC = CoverageSection->getContents(CoverageMapping)) - return errorCodeToError(EC); - if (Error E = ProfileNames.create(*NamesSection)) - return E; + if (std::error_code EC = CoverageSection->getContents(CoverageMapping)) + return EC; + if (std::error_code EC = ProfileNames.create(*NamesSection)) + return EC; - return Error::success(); + return std::error_code(); } -Expected<std::unique_ptr<BinaryCoverageReader>> +ErrorOr<std::unique_ptr<BinaryCoverageReader>> BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer, StringRef Arch) { std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader()); @@ -564,44 +562,44 @@ BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer, StringRef Coverage; uint8_t BytesInAddress; support::endianness Endian; - Error E; - consumeError(std::move(E)); + std::error_code EC; if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic)) // This is a special format used for testing. - E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames, - Coverage, BytesInAddress, Endian); + EC = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames, + Coverage, BytesInAddress, Endian); else - E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames, - Coverage, BytesInAddress, Endian, Arch); - if (E) - return std::move(E); + EC = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames, + Coverage, BytesInAddress, Endian, Arch); + if (EC) + return EC; if (BytesInAddress == 4 && Endian == support::endianness::little) - E = readCoverageMappingData<uint32_t, support::endianness::little>( + EC = readCoverageMappingData<uint32_t, support::endianness::little>( Reader->ProfileNames, Coverage, Reader->MappingRecords, Reader->Filenames); else if (BytesInAddress == 4 && Endian == support::endianness::big) - E = readCoverageMappingData<uint32_t, support::endianness::big>( + EC = readCoverageMappingData<uint32_t, support::endianness::big>( Reader->ProfileNames, Coverage, Reader->MappingRecords, Reader->Filenames); else if (BytesInAddress == 8 && Endian == support::endianness::little) - E = readCoverageMappingData<uint64_t, support::endianness::little>( + EC = readCoverageMappingData<uint64_t, support::endianness::little>( Reader->ProfileNames, Coverage, Reader->MappingRecords, Reader->Filenames); else if (BytesInAddress == 8 && Endian == support::endianness::big) - E = readCoverageMappingData<uint64_t, support::endianness::big>( + EC = readCoverageMappingData<uint64_t, support::endianness::big>( Reader->ProfileNames, Coverage, Reader->MappingRecords, Reader->Filenames); else - return make_error<CoverageMapError>(coveragemap_error::malformed); - if (E) - return std::move(E); + return coveragemap_error::malformed; + if (EC) + return EC; return std::move(Reader); } -Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) { +std::error_code +BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) { if (CurrentRecord >= MappingRecords.size()) - return make_error<CoverageMapError>(coveragemap_error::eof); + return coveragemap_error::eof; FunctionsFilenames.clear(); Expressions.clear(); @@ -621,5 +619,5 @@ Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) { Record.MappingRegions = MappingRegions; ++CurrentRecord; - return Error::success(); + return std::error_code(); } |
