Revert "Retry^2 "[ProfileData] (llvm) Use Error in InstrProf and Coverage, NFC""

This reverts commit r269694. MSVC says:

error C2086: 'char llvm::ProfErrorInfoBase<enum llvm::instrprof_error>::ID' : redefinition

llvm-svn: 269700

1 files changed, 114 insertions, 116 deletions

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();
 }