1 files changed, 36 insertions, 50 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;