[ProfileData] (llvm) Use Error in InstrProf and Coverage

[vsk]

Summary

Transition InstrProf and Coverage over to the stricter Error/Expected interface.

This has several advantages:

1. It's impossible to ignore hard errors.
2. It's impossible to ignore breakages in code that *usually* returns "success" values.
3. It's easier to set breakpoints on specific error conditions (e.g, in the relevant ErrorInfoBase constructor), because we no longer create errors by returning raw enum values.

The only disadvantage I'm aware of is that in the event of an actual error, there is a malloc required.

This patch is motivated by my experiences with maintaining the swift compiler's code coverage functionality. Having stricter error checking would have helped us catch multiple bugs at testing time. Certain hard errors triggered by upstream changes wouldn't have been silently ignored.

I apologize for the large diff (thankfully it's very mechanical). Once I converted InstrProf, I had a hard time getting the Coverage code to work without converting it as well. Since there is no SampleProf <- InstrProf dependency, I will deal with it in a separate patch.

[davidxl]

include/llvm/ProfileData/InstrProf.h

282

Should it be templatized and share the def with CoverageMapError?

320

Document this interface

329

Document this interface.

[vsk]

include/llvm/ProfileData/InstrProf.h

282

Good point, I'll have this in the next revision. @lhames, could something like this be worth pulling into Support/Error.h?

[vsk]

• Document two static functions in InstrProfError.
• Share code between InstrProfError and CoverageMapError.

[lhames]

I think EnumBasedError is problematic: at a minimum it needs to implement the convertToErrorCode method, since it's part of the current Error contract. Clients must be allowed to convert to std::error_code to allow interoperability with code that hasn't switched to Error yet. That shouldn't be too much a headache. You just need to create an error category and move your existing to-string methods for the enum over to that. See e.g. lib/Object/Error.cpp for a simple error_category definition.

EnumBasedError probably shouldn't have its own create method either - wherever you're creating a success value you should just use Error::success(). Where you're creating a failure value you should use make_error<ErrT>(<enum value>);

include/llvm/ProfileData/InstrProf.h

282–303

InstrProfError (and CoverageMappingError) need their own ID members. If they don't have them the Error RTTI will treat them both as EnumBasedErrors.

[vsk]

I'll make the suggested fixes to EnumBasedError.

Based on Lang's feedback it seems like this class should live in ProfileData for now, on a trial basis. We could easily revisit this decision once we know more about whether or not each enum value kind should get its own ErrorInfoBase.

include/llvm/ProfileData/InstrProf.h

282–303

Yikes! Is this true even if I define distinct ID's for them? Specifically:

template <> char EnumBasedError<instrprof_error, InstrProfError>::ID = 0; // InstrProf.cpp
template <> char EnumBasedError<coveragemap_error, CoverageMapError>::ID = 0; // CoverageMapping.cpp

643–644

In the event of a large number of overflow errors, the malloc traffic out of this API might be a real performance concern. The same goes for all clients of InstrProfError::merge.

For now, I will re-work this to return a raw instrprof_error. In the future, we may want to change the API again to get the best of both worlds: undroppable errors and no memory overhead.

[davidxl]

include/llvm/ProfileData/InstrProf.h

282–303

Can you elaborate on the RTTI issue? Also what is the problem that can be caused with this (both Error treated as EnumBasedErrors)?

[lhames]

include/llvm/ProfileData/InstrProf.h

282–303

My bad! didn't stop to think about EnumBasedError being templated. I think having the ID on EnumBasedError like this should be safe.

[davidxl]

Any more update to the patch?

[vsk]

Sorry, I've had to deal with some failures in our internal branches. I'll update this patch shortly.

[vsk]

• Move EnumBasedError to ProfileCommon.h so SampleProf can reuse it later.
• Remove EnumBasedError::create(), remove the DerivedError CRTP, and use Error::success()/make_error<> everywhere explicitly.
• Honor the convertToErrorCode contract.

[vsk]

I think I addressed Lang's review feedback.

If http://reviews.llvm.org/D20082 looks good, I'd like to rebase onto it. After that it seems like we'd be in good shape.

include/llvm/ProfileData/InstrProf.h

282–303

@davidxl Here's an example where this could be a problem. Suppose classes A and B both inherit from class Parent, and that the storage for ID is shared. Then, a "B" error could be handled by a callback for "A" errors.

[vsk]

• Rebase onto master. This lets us incorporate SoftInstrProfErrors (see D20082).

[vsk]

• Fix a comment. takeError() resets the FirstError field.
• Remove accidentally added copy constructor and copy assignment method for InstrProfRecord.

[davidxl]

include/llvm/ProfileData/Coverage/CoverageMapping.h

47

no need for this overrider.

include/llvm/ProfileData/InstrProf.h

259

why this change?

288

no need for this override -- define in base.

include/llvm/ProfileData/ProfileCommon.h

41

The name seems to general. How about just ProfErrorInfoBase

lib/ProfileData/Coverage/CoverageMappingReader.cpp

45

Can this ever happen?

[vsk]

include/llvm/ProfileData/InstrProf.h

259

I did it to catch cases where we treat instrprof_errors as bools or ints. It isn't directly related to this patch so I'll remove the change.

lib/ProfileData/Coverage/CoverageMappingReader.cpp

45

Yes, thanks for pointing this out. In unittests/ProfileData/CoverageMappingTest.cpp, CoverageMappingReaderMock::readNextRecord() returns instrprof_error::eof instead of coveragemap_error::eof. Fixed in r269324.

[vsk]

Address David's review feedback.

• EnumBasedError -> ProfErrorInfoBase
• Clean up the log() overrides.
• Minimize the diff (don't change the "success" values, remove a #include of ManagedStatic.h from InstrProf.h)

[davidxl]

lgtm

include/llvm/ProfileData/Coverage/CoverageMapping.h

 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Endian.h"
-#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 #include <tuple>
 
 namespace llvm {
 namespace coverage {
+
 enum class coveragemap_error {
-  success = 0,
+  success,
   eof,
   no_data_found,
   unsupported_version,
   truncated,
   malformed
 };
-} // end of coverage namespace.
-}
 
-namespace std {
-template <>
-struct is_error_code_enum<llvm::coverage::coveragemap_error> : std::true_type {
+class CoverageMapError : public EnumBasedError<coveragemap_error> {
+public:
+  CoverageMapError(coveragemap_error Err)
+      : EnumBasedError<coveragemap_error>(Err) {}
+
+  void log(raw_ostream &OS) const override;
+
+  std::string message() const override;
 };
+
+} // end of coverage namespace.
 }
 
 namespace llvm {
 class IndexedInstrProfReader;
 namespace coverage {
 
 class CoverageMappingReader;
 
public:
 
   void setCounts(ArrayRef<uint64_t> Counts) { CounterValues = Counts; }
 
   void dump(const Counter &C, llvm::raw_ostream &OS) const;
   void dump(const Counter &C) const { dump(C, dbgs()); }
 
   /// \brief Return the number of times that a region of code associated with
   /// this counter was executed.
-  ErrorOr<int64_t> evaluate(const Counter &C) const;
+  Expected<int64_t> evaluate(const Counter &C) const;
 };
 
 /// \brief Code coverage information for a single function.
 struct FunctionRecord {
   /// \brief Raw function name.
   std::string Name;
   /// \brief Associated files.
   std::vector<std::string> Filenames;

 class CoverageMapping {
   std::vector<FunctionRecord> Functions;
   unsigned MismatchedFunctionCount;
 
   CoverageMapping() : MismatchedFunctionCount(0) {}
 
 public:
   /// \brief Load the coverage mapping using the given readers.
-  static ErrorOr<std::unique_ptr<CoverageMapping>>
+  static Expected<std::unique_ptr<CoverageMapping>>
   load(CoverageMappingReader &CoverageReader,
        IndexedInstrProfReader &ProfileReader);
 
   /// \brief Load the coverage mapping from the given files.
-  static ErrorOr<std::unique_ptr<CoverageMapping>>
+  static Expected<std::unique_ptr<CoverageMapping>>
   load(StringRef ObjectFilename, StringRef ProfileFilename,
        StringRef Arch = StringRef());
 
   /// \brief The number of functions that couldn't have their profiles mapped.
   ///
   /// This is a count of functions whose profile is out of date or otherwise
   /// can't be associated with any coverage information.
   unsigned getMismatchedCount() { return MismatchedFunctionCount; }
template <support::endianness Endian> uint32_t getDataSize() const {
     return support::endian::byte_swap<uint32_t, Endian>(DataSize);
   }
   // Return function lookup key. The value is consider opaque.
   template <support::endianness Endian> IntPtrT getFuncNameRef() const {
     return support::endian::byte_swap<IntPtrT, Endian>(NamePtr);
   }
   // Return the PGO name of the function */
   template <support::endianness Endian>
-  std::error_code getFuncName(InstrProfSymtab &ProfileNames,
-                              StringRef &FuncName) const {
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
     IntPtrT NameRef = getFuncNameRef<Endian>();
     uint32_t NameS = support::endian::byte_swap<uint32_t, Endian>(NameSize);
     FuncName = ProfileNames.getFuncName(NameRef, NameS);
     if (NameS && FuncName.empty())
-      return coveragemap_error::malformed;
-    return std::error_code();
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
+    return Error::success();
   }
 };
 
 struct CovMapFunctionRecord {
 #define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
 #include "llvm/ProfileData/InstrProfData.inc"
 
   // Return the structural hash associated with the function.
   template <support::endianness Endian> uint64_t getFuncHash() const {
     return support::endian::byte_swap<uint64_t, Endian>(FuncHash);
   }
   // Return the coverage map data size for the funciton.
   template <support::endianness Endian> uint32_t getDataSize() const {
     return support::endian::byte_swap<uint32_t, Endian>(DataSize);
   }
   // Return function lookup key. The value is consider opaque.
   template <support::endianness Endian> uint64_t getFuncNameRef() const {
     return support::endian::byte_swap<uint64_t, Endian>(NameRef);
   }
   // Return the PGO name of the function */
   template <support::endianness Endian>
-  std::error_code getFuncName(InstrProfSymtab &ProfileNames,
-                              StringRef &FuncName) const {
+  Error getFuncName(InstrProfSymtab &ProfileNames, StringRef &FuncName) const {
     uint64_t NameRef = getFuncNameRef<Endian>();
     FuncName = ProfileNames.getFuncName(NameRef);
-    return std::error_code();
+    return Error::success();
   }
 };
 
 // Per module coverage mapping data header, i.e. CoverageMapFileHeader
 // documented above.
 struct CovMapHeader {
 #define COVMAP_HEADER(Type, LLVMType, Name, Init) Type Name;
 #include "llvm/ProfileData/InstrProfData.inc"

include/llvm/ProfileData/Coverage/CoverageMappingReader.h

bool operator!=(const CoverageMappingIterator &RHS) {
     return Reader != RHS.Reader;
   }
   CoverageMappingRecord &operator*() { return Record; }
   CoverageMappingRecord *operator->() { return &Record; }
 };
 
 class CoverageMappingReader {
 public:
-  virtual std::error_code readNextRecord(CoverageMappingRecord &Record) = 0;
+  virtual Error readNextRecord(CoverageMappingRecord &Record) = 0;
   CoverageMappingIterator begin() { return CoverageMappingIterator(this); }
   CoverageMappingIterator end() { return CoverageMappingIterator(); }
   virtual ~CoverageMappingReader() {}
 };
 
 /// \brief Base class for the raw coverage mapping and filenames data readers.
 class RawCoverageReader {
 protected:
   StringRef Data;
 
   RawCoverageReader(StringRef Data) : Data(Data) {}
 
-  std::error_code readULEB128(uint64_t &Result);
-  std::error_code readIntMax(uint64_t &Result, uint64_t MaxPlus1);
-  std::error_code readSize(uint64_t &Result);
-  std::error_code readString(StringRef &Result);
+  Error readULEB128(uint64_t &Result);
+  Error readIntMax(uint64_t &Result, uint64_t MaxPlus1);
+  Error readSize(uint64_t &Result);
+  Error readString(StringRef &Result);
 };
 
 /// \brief Reader for the raw coverage filenames.
 class RawCoverageFilenamesReader : public RawCoverageReader {
   std::vector<StringRef> &Filenames;
 
   RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
   RawCoverageFilenamesReader &
   operator=(const RawCoverageFilenamesReader &) = delete;
 
 public:
   RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
       : RawCoverageReader(Data), Filenames(Filenames) {}
 
-  std::error_code read();
+  Error read();
 };
 
 /// \brief Reader for the raw coverage mapping data.
 class RawCoverageMappingReader : public RawCoverageReader {
   ArrayRef<StringRef> TranslationUnitFilenames;
   std::vector<StringRef> &Filenames;
   std::vector<CounterExpression> &Expressions;
   std::vector<CounterMappingRegion> &MappingRegions;
 
   RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
   RawCoverageMappingReader &
   operator=(const RawCoverageMappingReader &) = delete;
 
 public:
   RawCoverageMappingReader(StringRef MappingData,
                            ArrayRef<StringRef> TranslationUnitFilenames,
                            std::vector<StringRef> &Filenames,
                            std::vector<CounterExpression> &Expressions,
                            std::vector<CounterMappingRegion> &MappingRegions)
       : RawCoverageReader(MappingData),
         TranslationUnitFilenames(TranslationUnitFilenames),
         Filenames(Filenames), Expressions(Expressions),
         MappingRegions(MappingRegions) {}
 
-  std::error_code read();
+  Error read();
 
 private:
-  std::error_code decodeCounter(unsigned Value, Counter &C);
-  std::error_code readCounter(Counter &C);
-  std::error_code
+  Error decodeCounter(unsigned Value, Counter &C);
+  Error readCounter(Counter &C);
+  Error
   readMappingRegionsSubArray(std::vector<CounterMappingRegion> &MappingRegions,
                              unsigned InferredFileID, size_t NumFileIDs);
 };
 
 /// \brief Reader for the coverage mapping data that is emitted by the
 /// frontend and stored in an object file.
 class BinaryCoverageReader : public CoverageMappingReader {
 public:
private:
   std::vector<CounterMappingRegion> MappingRegions;
 
   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
   BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
 
   BinaryCoverageReader() : CurrentRecord(0) {}
 
 public:
-  static ErrorOr<std::unique_ptr<BinaryCoverageReader>>
+  static Expected<std::unique_ptr<BinaryCoverageReader>>
   create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
          StringRef Arch);
 
-  std::error_code readNextRecord(CoverageMappingRecord &Record) override;
+  Error readNextRecord(CoverageMappingRecord &Record) override;
 };
 
 } // end namespace coverage
 } // end namespace llvm
 
 #endif

include/llvm/ProfileData/InstrProf.h

 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/ProfileData/InstrProfData.inc"
 #include "llvm/ProfileData/ProfileCommon.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MD5.h"
+#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MathExtras.h"
 #include <cstdint>
 #include <list>
 #include <system_error>
 #include <vector>
 
 namespace llvm {
 

 /// method generates a combined string \c Result thatis ready to be
 /// serialized.  The \c Result string is comprised of three fields:
 /// The first field is the legnth of the uncompressed strings, and the
 /// the second field is the length of the zlib-compressed string.
 /// Both fields are encoded in ULEB128.  If \c doCompress is false, the
 ///  third field is the uncompressed strings; otherwise it is the
 /// compressed string. When the string compression is off, the
 /// second field will have value zero.
-std::error_code
-collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
+Error collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
                                 bool doCompression, std::string &Result);
 /// Produce \c Result string with the same format described above. The input
 /// is vector of PGO function name variables that are referenced.
-std::error_code
-collectPGOFuncNameStrings(const std::vector<GlobalVariable *> &NameVars,
+Error collectPGOFuncNameStrings(const std::vector<GlobalVariable *> &NameVars,
                                 std::string &Result, bool doCompression = true);
 class InstrProfSymtab;
 /// \c NameStrings is a string composed of one of more sub-strings encoded in
 /// the format described above. The substrings are seperated by 0 or more zero
 /// bytes. This method decodes the string and populates the \c Symtab.
-std::error_code readPGOFuncNameStrings(StringRef NameStrings,
-                                       InstrProfSymtab &Symtab);
+Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab);
 
 enum InstrProfValueKind : uint32_t {
 #define VALUE_PROF_KIND(Enumerator, Value) Enumerator = Value,
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
 struct InstrProfRecord;
 

 /// Return the PGOFuncName meta data associated with a function.
 MDNode *getPGOFuncNameMetadata(const Function &F);
 
 /// Create the PGOFuncName meta data if PGOFuncName is different from
 /// function's raw name. This should only apply to internal linkage functions
 /// declared by users only.
 void createPGOFuncNameMetadata(Function &F, const std::string &PGOFuncName);
 
-const std::error_category &instrprof_category();
-
 enum class instrprof_error {
-  success = 0,
+  success,
   eof,
   unrecognized_format,
   bad_magic,
   bad_header,
   unsupported_version,
   unsupported_hash_type,
   too_large,
   truncated,
   malformed,
   unknown_function,
   hash_mismatch,
   count_mismatch,
   counter_overflow,
   value_site_count_mismatch,
   compress_failed,
   uncompress_failed
 };
 
+const std::error_category &instrprof_category();
+
 inline std::error_code make_error_code(instrprof_error E) {
   return std::error_code(static_cast<int>(E), instrprof_category());
 }
 
+class InstrProfError : public EnumBasedError<instrprof_error> {
+public:
+  InstrProfError(instrprof_error Err) : EnumBasedError<instrprof_error>(Err) {}
+
+  void log(raw_ostream &OS) const override;
+
+  std::string message() const override;
+
+  /// Consume an Error and return the raw enum value contained within it. The
+  /// Error must either be a success value, or contain a single InstrProfError.
+  static instrprof_error take(Error E) {
+    auto Err = instrprof_error::success;
+    handleAllErrors(std::move(E), [&Err](const InstrProfError &IPE) {
+      assert(Err == instrprof_error::success && "Multiple errors encountered");
+      Err = IPE.get();
+    });
+    return Err;
+  }
+};
+
 class SoftInstrProfErrors {
   /// Count the number of soft instrprof_errors encountered and keep track of
   /// the first such error for reporting purposes.
 
   /// The first soft error encountered.
   instrprof_error FirstError;
 
   /// The number of hash mismatches.
   unsigned NumHashMismatches;
 
   /// The number of count mismatches.
   unsigned NumCountMismatches;
 
   /// The number of counter overflows.
   unsigned NumCounterOverflows;
 
   /// The number of value site count mismatches.
   unsigned NumValueSiteCountMismatches;
 
 public:
   SoftInstrProfErrors()
       : FirstError(instrprof_error::success), NumHashMismatches(0),
         NumCountMismatches(0), NumCounterOverflows(0),
         NumValueSiteCountMismatches(0) {}
 
+  ~SoftInstrProfErrors() {
+    assert(FirstError == instrprof_error::success &&
+           "Unchecked soft error encountered");
+  }
+
   /// Track a soft error (\p IE) and increment its associated counter.
   void addError(instrprof_error IE);
 
   /// Get the number of hash mismatches.
   unsigned getNumHashMismatches() const { return NumHashMismatches; }
 
   /// Get the number of count mismatches.
   unsigned getNumCountMismatches() const { return NumCountMismatches; }
 
   /// Get the number of counter overflows.
   unsigned getNumCounterOverflows() const { return NumCounterOverflows; }
 
   /// Get the number of value site count mismatches.
   unsigned getNumValueSiteCountMismatches() const {
     return NumValueSiteCountMismatches;
   }
 
-  /// Return an error code for the first encountered error.
-  std::error_code getError() const { return make_error_code(FirstError); }
+  /// Return the first encountered error.
+  Error takeError() {
+    if (FirstError == instrprof_error::success)
+      return Error::success();
+    auto E = make_error<InstrProfError>(FirstError);
+    FirstError = instrprof_error::success;
+    return E;
+  }
 };
 
 namespace object {
 class SectionRef;
 }
 
 namespace IndexedInstrProf {
 uint64_t ComputeHash(StringRef K);
InstrProfSymtab()
       AddrToMD5Map() {}
 
   /// Create InstrProfSymtab from an object file section which
   /// contains function PGO names. When section may contain raw
   /// string data or string data in compressed form. This method
   /// only initialize the symtab with reference to the data and
   /// the section base address. The decompression will be delayed
   /// until before it is used. See also \c create(StringRef) method.
-  std::error_code create(object::SectionRef &Section);
+  Error create(object::SectionRef &Section);
   /// This interface is used by reader of CoverageMapping test
   /// format.
-  inline std::error_code create(StringRef D, uint64_t BaseAddr);
+  inline Error create(StringRef D, uint64_t BaseAddr);
   /// \c NameStrings is a string composed of one of more sub-strings
   ///  encoded in the format described in \c collectPGOFuncNameStrings.
   /// This method is a wrapper to \c readPGOFuncNameStrings method.
-  inline std::error_code create(StringRef NameStrings);
+  inline Error create(StringRef NameStrings);
   /// A wrapper interface to populate the PGO symtab with functions
   /// decls from module \c M. This interface is used by transformation
   /// passes such as indirect function call promotion. Variable \c InLTO
   /// indicates if this is called from LTO optimization passes.
   void create(Module &M, bool InLTO = false);
   /// Create InstrProfSymtab from a set of names iteratable from
   /// \p IterRange. This interface is used by IndexedProfReader.
   template <typename NameIterRange> void create(const NameIterRange &IterRange);
public:
   /// Return the function's original assembly name by stripping off
   /// the prefix attached (to symbols with priviate linkage). For
   /// global functions, it returns the same string as getFuncName.
   inline StringRef getOrigFuncName(uint64_t FuncMD5Hash);
   /// Return the name section data.
   inline StringRef getNameData() const { return Data; }
 };
 
-std::error_code InstrProfSymtab::create(StringRef D, uint64_t BaseAddr) {
+Error InstrProfSymtab::create(StringRef D, uint64_t BaseAddr) {
   Data = D;
   Address = BaseAddr;
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code InstrProfSymtab::create(StringRef NameStrings) {
+Error InstrProfSymtab::create(StringRef NameStrings) {
   return readPGOFuncNameStrings(NameStrings, *this);
 }
 
 template <typename NameIterRange>
 void InstrProfSymtab::create(const NameIterRange &IterRange) {
   for (auto Name : IterRange)
     addFuncName(Name);
 
InstrProfRecord(StringRef Name, uint64_t Hash, std::vector<uint64_t> Counts)
       : Name(Name), Hash(Hash), Counts(std::move(Counts)), SIPE() {}
   StringRef Name;
   uint64_t Hash;
   std::vector<uint64_t> Counts;
   SoftInstrProfErrors SIPE;
 
   typedef std::vector<std::pair<uint64_t, uint64_t>> ValueMapType;
 
+  InstrProfRecord(const InstrProfRecord &IPR)
+      : Name(IPR.Name), Hash(IPR.Hash), Counts(IPR.Counts), SIPE(),
+        IndirectCallSites(IPR.IndirectCallSites) {}
+
+  InstrProfRecord &operator=(const InstrProfRecord &IPR) {
+    Name = IPR.Name;
+    Hash = IPR.Hash;
+    Counts = IPR.Counts;
+    IndirectCallSites = IPR.IndirectCallSites;
+    return *this;
+  }
+
   /// Return the number of value profile kinds with non-zero number
   /// of profile sites.
   inline uint32_t getNumValueKinds() const;
   /// Return the number of instrumented sites for ValueKind.
   inline uint32_t getNumValueSites(uint32_t ValueKind) const;
   /// Return the total number of ValueData for ValueKind.
   inline uint32_t getNumValueData(uint32_t ValueKind) const;
   /// Return the number of value data collected for ValueKind at profiling
struct InstrProfRecord {
   }
   /// Clear value data entries
   void clearValueData() {
     for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
       getValueSitesForKind(Kind).clear();
   }
 
   /// Get the error contained within the record's soft error counter.
-  std::error_code getError() const { return SIPE.getError(); }
+  Error takeError() { return SIPE.takeError(); }
 
 private:
   std::vector<InstrProfValueSiteRecord> IndirectCallSites;
   const std::vector<InstrProfValueSiteRecord> &
   getValueSitesForKind(uint32_t ValueKind) const {
     switch (ValueKind) {
     case IPVK_IndirectCallTarget:
       return IndirectCallSites;
private:
   }
 
   // Map indirect call target name hash to name string.
   uint64_t remapValue(uint64_t Value, uint32_t ValueKind,
                       ValueMapType *HashKeys);
 
   // Merge Value Profile data from Src record to this record for ValueKind.
   // Scale merged value counts by \p Weight.
   void mergeValueProfData(uint32_t ValueKind, InstrProfRecord &Src,
                           uint64_t Weight);
   // Scale up value profile data count.
   void scaleValueProfData(uint32_t ValueKind, uint64_t Weight);
 };
 
 uint32_t InstrProfRecord::getNumValueKinds() const {
   uint32_t NumValueKinds = 0;
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)
     NumValueKinds += !(getValueSitesForKind(Kind).empty());

 #define INSTR_PROF_RAW_HEADER(Type, Name, Init) const Type Name;
 #include "llvm/ProfileData/InstrProfData.inc"
 };
 
 } // end namespace RawInstrProf
 
 } // end namespace llvm
 
-namespace std {
-template <>
-struct is_error_code_enum<llvm::instrprof_error> : std::true_type {};
-}
-
 #endif // LLVM_PROFILEDATA_INSTRPROF_H

include/llvm/ProfileData/InstrProfData.inc

#if __cplusplus
    */
   static uint32_t getSize(const InstrProfRecord &Record);
   /*!
    * Return a pointer to \c ValueProfData instance ready to be streamed.
    */
   static std::unique_ptr<ValueProfData>
   serializeFrom(const InstrProfRecord &Record);
   /*!
-   * Check the integrity of the record. Return the error code when
-   * an error is detected, otherwise return instrprof_error::success.
+   * Check the integrity of the record.
    */
-  instrprof_error checkIntegrity();
+  Error checkIntegrity();
   /*!
    * Return a pointer to \c ValueProfileData instance ready to be read.
    * All data in the instance are properly byte swapped. The input
    * data is assumed to be in little endian order.
    */
-  static ErrorOr<std::unique_ptr<ValueProfData>>
+  static Expected<std::unique_ptr<ValueProfData>>
   getValueProfData(const unsigned char *SrcBuffer,
                    const unsigned char *const SrcBufferEnd,
                    support::endianness SrcDataEndianness);
   /*!
    * Swap byte order from \c Endianness order to host byte order.
    */
   void swapBytesToHost(support::endianness Endianness);
   /*!

include/llvm/ProfileData/InstrProfReader.h

 
 #ifndef LLVM_PROFILEDATA_INSTRPROFREADER_H
 #define LLVM_PROFILEDATA_INSTRPROFREADER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ProfileData/InstrProf.h"
 #include "llvm/Support/EndianStream.h"
-#include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/LineIterator.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/OnDiskHashTable.h"
 #include "llvm/Support/raw_ostream.h"
 #include <iterator>
 
 namespace llvm {
 
public:
   bool operator!=(const InstrProfIterator &RHS) { return Reader != RHS.Reader; }
   InstrProfRecord &operator*() { return Record; }
   InstrProfRecord *operator->() { return &Record; }
 };
 
 /// Base class and interface for reading profiling data of any known instrprof
 /// format. Provides an iterator over InstrProfRecords.
 class InstrProfReader {
-  std::error_code LastError;
+  instrprof_error LastError;
 
 public:
   InstrProfReader() : LastError(instrprof_error::success), Symtab() {}
   virtual ~InstrProfReader() {}
 
   /// Read the header.  Required before reading first record.
-  virtual std::error_code readHeader() = 0;
+  virtual Error readHeader() = 0;
   /// Read a single record.
-  virtual std::error_code readNextRecord(InstrProfRecord &Record) = 0;
+  virtual Error readNextRecord(InstrProfRecord &Record) = 0;
   /// Iterator over profile data.
   InstrProfIterator begin() { return InstrProfIterator(this); }
   InstrProfIterator end() { return InstrProfIterator(); }
   virtual bool isIRLevelProfile() const = 0;
 
   /// Return the PGO symtab. There are three different readers:
   /// Raw, Text, and Indexed profile readers. The first two types
   /// of readers are used only by llvm-profdata tool, while the indexed
   /// profile reader is also used by llvm-cov tool and the compiler (
   /// backend or frontend). Since creating PGO symtab can create
   /// significant runtime and memory overhead (as it touches data
   /// for the whole program), InstrProfSymtab for the indexed profile
   /// reader should be created on demand and it is recommended to be
   /// only used for dumping purpose with llvm-proftool, not with the
   /// compiler.
   virtual InstrProfSymtab &getSymtab() = 0;
 
 protected:
   std::unique_ptr<InstrProfSymtab> Symtab;
-  /// Set the current std::error_code and return same.
-  std::error_code error(std::error_code EC) {
-    LastError = EC;
-    return EC;
+  /// Set the current error and return same.
+  Error error(instrprof_error Err) {
+    LastError = Err;
+    if (Err == instrprof_error::success)
+      return Error::success();
+    return make_error<InstrProfError>(Err);
   }
+  Error error(Error E) { return error(InstrProfError::take(std::move(E))); }
 
-  /// Clear the current error code and return a successful one.
-  std::error_code success() { return error(instrprof_error::success); }
+  /// Clear the current error and return a successful one.
+  Error success() { return error(instrprof_error::success); }
 
 public:
   /// Return true if the reader has finished reading the profile data.
   bool isEOF() { return LastError == instrprof_error::eof; }
   /// Return true if the reader encountered an error reading profiling data.
-  bool hasError() { return LastError && !isEOF(); }
-  /// Get the current error code.
-  std::error_code getError() { return LastError; }
+  bool hasError() { return LastError != instrprof_error::success && !isEOF(); }
+  /// Get the current error.
+  Error getError() { return make_error<InstrProfError>(LastError); }
 
   /// Factory method to create an appropriately typed reader for the given
   /// instrprof file.
-  static ErrorOr<std::unique_ptr<InstrProfReader>> create(std::string Path);
+  static Expected<std::unique_ptr<InstrProfReader>> create(std::string Path);
 
-  static ErrorOr<std::unique_ptr<InstrProfReader>>
+  static Expected<std::unique_ptr<InstrProfReader>>
   create(std::unique_ptr<MemoryBuffer> Buffer);
 };
 
 /// Reader for the simple text based instrprof format.
 ///
 /// This format is a simple text format that's suitable for test data. Records
 /// are separated by one or more blank lines, and record fields are separated by
 /// new lines.
 ///
 /// Each record consists of a function name, a function hash, a number of
 /// counters, and then each counter value, in that order.
 class TextInstrProfReader : public InstrProfReader {
 private:
   /// The profile data file contents.
   std::unique_ptr<MemoryBuffer> DataBuffer;
   /// Iterator over the profile data.
   line_iterator Line;
   bool IsIRLevelProfile;
 
   TextInstrProfReader(const TextInstrProfReader &) = delete;
   TextInstrProfReader &operator=(const TextInstrProfReader &) = delete;
-  std::error_code readValueProfileData(InstrProfRecord &Record);
+  Error readValueProfileData(InstrProfRecord &Record);
 
 public:
   TextInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer_)
       : DataBuffer(std::move(DataBuffer_)), Line(*DataBuffer, true, '#'),
         IsIRLevelProfile(false) {}
 
   /// Return true if the given buffer is in text instrprof format.
   static bool hasFormat(const MemoryBuffer &Buffer);
 
   bool isIRLevelProfile() const override { return IsIRLevelProfile; }
 
   /// Read the header.
-  std::error_code readHeader() override;
+  Error readHeader() override;
   /// Read a single record.
-  std::error_code readNextRecord(InstrProfRecord &Record) override;
+  Error readNextRecord(InstrProfRecord &Record) override;
 
   InstrProfSymtab &getSymtab() override {
     assert(Symtab.get());
     return *Symtab.get();
   }
 };
 
 /// Reader for the raw instrprof binary format from runtime.
private:
 
   RawInstrProfReader(const RawInstrProfReader &) = delete;
   RawInstrProfReader &operator=(const RawInstrProfReader &) = delete;
 public:
   RawInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
       : DataBuffer(std::move(DataBuffer)) { }
 
   static bool hasFormat(const MemoryBuffer &DataBuffer);
-  std::error_code readHeader() override;
-  std::error_code readNextRecord(InstrProfRecord &Record) override;
+  Error readHeader() override;
+  Error readNextRecord(InstrProfRecord &Record) override;
   bool isIRLevelProfile() const override {
     return (Version & VARIANT_MASK_IR_PROF) != 0;
   }
 
   InstrProfSymtab &getSymtab() override {
     assert(Symtab.get());
     return *Symtab.get();
   }
 
 private:
-  std::error_code createSymtab(InstrProfSymtab &Symtab);
-  std::error_code readNextHeader(const char *CurrentPos);
-  std::error_code readHeader(const RawInstrProf::Header &Header);
+  Error createSymtab(InstrProfSymtab &Symtab);
+  Error readNextHeader(const char *CurrentPos);
+  Error readHeader(const RawInstrProf::Header &Header);
   template <class IntT> IntT swap(IntT Int) const {
     return ShouldSwapBytes ? sys::getSwappedBytes(Int) : Int;
   }
   support::endianness getDataEndianness() const {
     support::endianness HostEndian = getHostEndianness();
     if (!ShouldSwapBytes)
       return HostEndian;
     if (HostEndian == support::little)
       return support::big;
     else
       return support::little;
   }
 
   inline uint8_t getNumPaddingBytes(uint64_t SizeInBytes) {
     return 7 & (sizeof(uint64_t) - SizeInBytes % sizeof(uint64_t));
   }
-  std::error_code readName(InstrProfRecord &Record);
-  std::error_code readFuncHash(InstrProfRecord &Record);
-  std::error_code readRawCounts(InstrProfRecord &Record);
-  std::error_code readValueProfilingData(InstrProfRecord &Record);
+  Error readName(InstrProfRecord &Record);
+  Error readFuncHash(InstrProfRecord &Record);
+  Error readRawCounts(InstrProfRecord &Record);
+  Error readValueProfilingData(InstrProfRecord &Record);
   bool atEnd() const { return Data == DataEnd; }
   void advanceData() {
     Data++;
     ValueDataStart += CurValueDataSize;
   }
   const char *getNextHeaderPos() const {
       assert(atEnd());
       return (const char *)ValueDataStart;
public:
   void setValueProfDataEndianness(support::endianness Endianness) {
     ValueProfDataEndianness = Endianness;
   }
 };
 
 struct InstrProfReaderIndexBase {
   // Read all the profile records with the same key pointed to the current
   // iterator.
-  virtual std::error_code getRecords(ArrayRef<InstrProfRecord> &Data) = 0;
+  virtual Error getRecords(ArrayRef<InstrProfRecord> &Data) = 0;
   // Read all the profile records with the key equal to FuncName
-  virtual std::error_code getRecords(StringRef FuncName,
+  virtual Error getRecords(StringRef FuncName,
                                      ArrayRef<InstrProfRecord> &Data) = 0;
   virtual void advanceToNextKey() = 0;
   virtual bool atEnd() const = 0;
   virtual void setValueProfDataEndianness(support::endianness Endianness) = 0;
   virtual ~InstrProfReaderIndexBase() {}
   virtual uint64_t getVersion() const = 0;
   virtual bool isIRLevelProfile() const = 0;
   virtual void populateSymtab(InstrProfSymtab &) = 0;
private:
   uint64_t FormatVersion;
 
 public:
   InstrProfReaderIndex(const unsigned char *Buckets,
                        const unsigned char *const Payload,
                        const unsigned char *const Base,
                        IndexedInstrProf::HashT HashType, uint64_t Version);
 
-  std::error_code getRecords(ArrayRef<InstrProfRecord> &Data) override;
-  std::error_code getRecords(StringRef FuncName,
-                             ArrayRef<InstrProfRecord> &Data) override;
+  Error getRecords(ArrayRef<InstrProfRecord> &Data) override;
+  Error getRecords(StringRef FuncName,
   void advanceToNextKey() override { RecordIterator++; }
   bool atEnd() const override {
     return RecordIterator == HashTable->data_end();
   }
   void setValueProfDataEndianness(support::endianness Endianness) override {
     HashTable->getInfoObj().setValueProfDataEndianness(Endianness);
   }
   ~InstrProfReaderIndex() override {}
public:
   bool isIRLevelProfile() const override { return Index->isIRLevelProfile(); }
   IndexedInstrProfReader(std::unique_ptr<MemoryBuffer> DataBuffer)
       : DataBuffer(std::move(DataBuffer)), Index(nullptr) {}
 
   /// Return true if the given buffer is in an indexed instrprof format.
   static bool hasFormat(const MemoryBuffer &DataBuffer);
 
   /// Read the file header.
-  std::error_code readHeader() override;
+  Error readHeader() override;
   /// Read a single record.
-  std::error_code readNextRecord(InstrProfRecord &Record) override;
+  Error readNextRecord(InstrProfRecord &Record) override;
 
   /// Return the pointer to InstrProfRecord associated with FuncName
   /// and FuncHash
-  ErrorOr<InstrProfRecord> getInstrProfRecord(StringRef FuncName,
+  Expected<InstrProfRecord> getInstrProfRecord(StringRef FuncName,
                                                uint64_t FuncHash);
 
   /// Fill Counts with the profile data for the given function name.
-  std::error_code getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
-                                    std::vector<uint64_t> &Counts);
+  Error getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
 
   /// Return the maximum of all known function counts.
   uint64_t getMaximumFunctionCount() { return Summary->getMaxFunctionCount(); }
 
   /// Factory method to create an indexed reader.
-  static ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
+  static Expected<std::unique_ptr<IndexedInstrProfReader>>
   create(std::string Path);
 
-  static ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
+  static Expected<std::unique_ptr<IndexedInstrProfReader>>
   create(std::unique_ptr<MemoryBuffer> Buffer);
 
   // Used for testing purpose only.
   void setValueProfDataEndianness(support::endianness Endianness) {
     Index->setValueProfDataEndianness(Endianness);
   }
 
   // See description in the base class. This interface is designed

include/llvm/ProfileData/InstrProfWriter.h

 
 public:
   InstrProfWriter(bool Sparse = false);
   ~InstrProfWriter();
 
   /// Add function counts for the given function. If there are already counts
   /// for this function and the hash and number of counts match, each counter is
   /// summed. Optionally scale counts by \p Weight.
-  std::error_code addRecord(InstrProfRecord &&I, uint64_t Weight = 1);
+  Error addRecord(InstrProfRecord &&I, uint64_t Weight = 1);
   /// Write the profile to \c OS
   void write(raw_fd_ostream &OS);
   /// Write the profile in text format to \c OS
   void writeText(raw_fd_ostream &OS);
   /// Write \c Record in text format to \c OS
   static void writeRecordInText(const InstrProfRecord &Record,
                                 InstrProfSymtab &Symtab, raw_fd_ostream &OS);
   /// Write the profile, returning the raw data. For testing.
   std::unique_ptr<MemoryBuffer> writeBuffer();
 
   /// Set the ProfileKind. Report error if mixing FE and IR level profiles.
-  std::error_code setIsIRLevelProfile(bool IsIRLevel) {
+  Error setIsIRLevelProfile(bool IsIRLevel) {
     if (ProfileKind == PF_Unknown) {
       ProfileKind = IsIRLevel ? PF_IRLevel: PF_FE;
-      return instrprof_error::success;
+      return Error::success();
     }
-    return (IsIRLevel == (ProfileKind == PF_IRLevel)) ?
-           instrprof_error::success : instrprof_error::unsupported_version;
+    return (IsIRLevel == (ProfileKind == PF_IRLevel))
+               ? Error::success()
+               : make_error<InstrProfError>(
+                     instrprof_error::unsupported_version);
   }
 
   // Internal interface for testing purpose only.
   void setValueProfDataEndianness(support::endianness Endianness);
   void setOutputSparse(bool Sparse);
 
 private:
   bool shouldEncodeData(const ProfilingData &PD);
   void writeImpl(ProfOStream &OS);
 };
 
 } // end namespace llvm
 
 #endif

include/llvm/ProfileData/ProfileCommon.h

 #define LLVM_PROFILEDATA_PROFILE_COMMON_H
 
 #include <cstdint>
 #include <functional>
 #include <map>
 #include <vector>
 
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
 
 namespace llvm {
 class Function;
 namespace IndexedInstrProf {
 struct Summary;
 }
 namespace sampleprof {
 class FunctionSamples;
 }
 struct InstrProfRecord;
 class LLVMContext;
 class Metadata;
 class MDTuple;
 class MDNode;
 
+template <typename ErrT>
+class EnumBasedError : public ErrorInfo<EnumBasedError<ErrT>> {
+public:
+  EnumBasedError(ErrT Err) : Err(Err) {
+    assert(Err != ErrT::success && "Not an error");
+  }
+
+  std::error_code convertToErrorCode() const override {
+    return make_error_code(Err);
+  }
+
+  ErrT get() const { return Err; }
+
+  static char ID;
+
+protected:
+  ErrT Err;
+};
+
 inline const char *getHotSectionPrefix() { return ".hot"; }
 inline const char *getUnlikelySectionPrefix() { return ".unlikely"; }
 
 // The profile summary is one or more (Cutoff, MinCount, NumCounts) triplets.
 // The semantics of counts depend on the type of profile. For instrumentation
 // profile, counts are block counts and for sample profile, counts are
 // per-line samples. Given a target counts percentile, we compute the minimum
 // number of counts needed to reach this target and the minimum among these

lib/ProfileData/Coverage/CoverageMapping.cpp

case Counter::Expression: {
     OS << (E.Kind == CounterExpression::Subtract ? " - " : " + ");
     dump(E.RHS, OS);
     OS << ')';
     break;
   }
   }
   if (CounterValues.empty())
     return;
-  ErrorOr<int64_t> Value = evaluate(C);
-  if (!Value)
+  Expected<int64_t> Value = evaluate(C);
+  if (auto E = Value.takeError()) {
+    llvm::consumeError(std::move(E));
     return;
+  }
   OS << '[' << *Value << ']';
 }
 
-ErrorOr<int64_t> CounterMappingContext::evaluate(const Counter &C) const {
+Expected<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 make_error_code(errc::argument_out_of_domain);
+      return errorCodeToError(errc::argument_out_of_domain);
     return CounterValues[C.getCounterID()];
   case Counter::Expression: {
     if (C.getExpressionID() >= Expressions.size())
-      return make_error_code(errc::argument_out_of_domain);
+      return errorCodeToError(errc::argument_out_of_domain);
     const auto &E = Expressions[C.getExpressionID()];
-    ErrorOr<int64_t> LHS = evaluate(E.LHS);
+    Expected<int64_t> LHS = evaluate(E.LHS);
     if (!LHS)
       return LHS;
-    ErrorOr<int64_t> RHS = evaluate(E.RHS);
+    Expected<int64_t> RHS = evaluate(E.RHS);
     if (!RHS)
       return RHS;
     return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS + *RHS;
   }
   }
   llvm_unreachable("Unhandled CounterKind");
 }
 
 void FunctionRecordIterator::skipOtherFiles() {
   while (Current != Records.end() && !Filename.empty() &&
          Filename != Current->Filenames[0])
     ++Current;
   if (Current == Records.end())
     *this = FunctionRecordIterator();
 }
 
-ErrorOr<std::unique_ptr<CoverageMapping>>
+Expected<std::unique_ptr<CoverageMapping>>
 CoverageMapping::load(CoverageMappingReader &CoverageReader,
                       IndexedInstrProfReader &ProfileReader) {
   auto Coverage = std::unique_ptr<CoverageMapping>(new CoverageMapping());
 
   std::vector<uint64_t> Counts;
   for (const auto &Record : CoverageReader) {
     CounterMappingContext Ctx(Record.Expressions);
 
     Counts.clear();
-    if (std::error_code EC = ProfileReader.getFunctionCounts(
+    if (Error E = ProfileReader.getFunctionCounts(
             Record.FunctionName, Record.FunctionHash, Counts)) {
-      if (EC == instrprof_error::hash_mismatch) {
+      instrprof_error IPE = InstrProfError::take(std::move(E));
+      if (IPE == instrprof_error::hash_mismatch) {
         Coverage->MismatchedFunctionCount++;
         continue;
-      } else if (EC != instrprof_error::unknown_function)
-        return EC;
+      } else if (IPE != instrprof_error::unknown_function)
+        return make_error<InstrProfError>(IPE);
       Counts.assign(Record.MappingRegions.size(), 0);
     }
     Ctx.setCounts(Counts);
 
     assert(!Record.MappingRegions.empty() && "Function has no regions");
 
     StringRef OrigFuncName = Record.FunctionName;
     if (Record.Filenames.empty())
       OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName);
     else
       OrigFuncName =
           getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]);
     FunctionRecord Function(OrigFuncName, Record.Filenames);
     for (const auto &Region : Record.MappingRegions) {
-      ErrorOr<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
-      if (!ExecutionCount)
+      Expected<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
+      if (auto E = ExecutionCount.takeError()) {
+        llvm::consumeError(std::move(E));
         break;
+      }
       Function.pushRegion(Region, *ExecutionCount);
     }
     if (Function.CountedRegions.size() != Record.MappingRegions.size()) {
       Coverage->MismatchedFunctionCount++;
       continue;
     }
 
     Coverage->Functions.push_back(std::move(Function));
   }
 
   return std::move(Coverage);
 }
 
-ErrorOr<std::unique_ptr<CoverageMapping>>
+Expected<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 EC;
+    return errorCodeToError(EC);
   auto CoverageReaderOrErr =
       BinaryCoverageReader::create(CounterMappingBuff.get(), Arch);
-  if (std::error_code EC = CoverageReaderOrErr.getError())
-    return EC;
+  if (Error E = CoverageReaderOrErr.takeError())
+    return std::move(E);
   auto CoverageReader = std::move(CoverageReaderOrErr.get());
   auto ProfileReaderOrErr = IndexedInstrProfReader::create(ProfileFilename);
-  if (auto EC = ProfileReaderOrErr.getError())
-    return EC;
+  if (Error E = ProfileReaderOrErr.takeError())
+    return std::move(E);
   auto ProfileReader = std::move(ProfileReaderOrErr.get());
   return load(*CoverageReader, *ProfileReader);
 }
 
 namespace {
 /// \brief Distributes functions into instantiation sets.
 ///
 /// An instantiation set is a collection of functions that have the same source
CoverageMapping::getCoverageForExpansion(const ExpansionRecord &Expansion) {
   DEBUG(dbgs() << "Emitting segments for expansion of file " << Expansion.FileID
                << "\n");
   ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
 
   return ExpansionCoverage;
 }
 
 namespace {
-class CoverageMappingErrorCategoryType : public std::error_category {
-  const char *name() const LLVM_NOEXCEPT override { return "llvm.coveragemap"; }
-  std::string message(int IE) const override {
-    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.");
-  }
+std::string getCoverageMapErrString(coveragemap_error Err) {
+  switch (Err) {
+
+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));
+  }
 };
+} // end anonymous namespace
+
+void CoverageMapError::log(raw_ostream &OS) const { OS << message(); }
+
+std::string CoverageMapError::message() const {
+  return getCoverageMapErrString(Err);
 }
 
 static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory;
 
 const std::error_category &llvm::coverage::coveragemap_category() {
   return *ErrorCategory;
 }
+
+template <> char EnumBasedError<coveragemap_error>::ID = 0;

lib/ProfileData/Coverage/CoverageMappingReader.cpp

 
 using namespace llvm;
 using namespace coverage;
 using namespace object;
 
 #define DEBUG_TYPE "coverage-mapping"
 
 void CoverageMappingIterator::increment() {
+  auto handleErrorIfEOF = [&](bool IsEOF) {
+    if (!IsEOF)
+      llvm_unreachable("Unexpected error in coverage mapping iterator");
+    *this = CoverageMappingIterator();
+  };
+
   // Check if all the records were read or if an error occurred while reading
   // the next record.
-  if (Reader->readNextRecord(Record))
-    *this = CoverageMappingIterator();
+  if (auto E = Reader->readNextRecord(Record)) {
+    handleAllErrors(std::move(E),
+                    [&](const CoverageMapError &CME) {
+                      handleErrorIfEOF(CME.get() == coveragemap_error::eof);
+                    },
+                    [&](const InstrProfError &IPE) {
+                      handleErrorIfEOF(IPE.get() == instrprof_error::eof);
+                    });
+  }
 }
 
-std::error_code RawCoverageReader::readULEB128(uint64_t &Result) {
+Error RawCoverageReader::readULEB128(uint64_t &Result) {
   if (Data.size() < 1)
-    return coveragemap_error::truncated;
+    return make_error<CoverageMapError>(coveragemap_error::truncated);
   unsigned N = 0;
   Result = decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
   if (N > Data.size())
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code RawCoverageReader::readIntMax(uint64_t &Result,
-                                              uint64_t MaxPlus1) {
+Error RawCoverageReader::readIntMax(uint64_t &Result, uint64_t MaxPlus1) {
   if (auto Err = readULEB128(Result))
     return Err;
   if (Result >= MaxPlus1)
-    return coveragemap_error::malformed;
-  return std::error_code();
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
+  return Error::success();
 }
 
-std::error_code RawCoverageReader::readSize(uint64_t &Result) {
+Error RawCoverageReader::readSize(uint64_t &Result) {
   if (auto Err = readULEB128(Result))
     return Err;
   // Sanity check the number.
   if (Result > Data.size())
-    return coveragemap_error::malformed;
-  return std::error_code();
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
+  return Error::success();
 }
 
-std::error_code RawCoverageReader::readString(StringRef &Result) {
+Error RawCoverageReader::readString(StringRef &Result) {
   uint64_t Length;
   if (auto Err = readSize(Length))
     return Err;
   Result = Data.substr(0, Length);
   Data = Data.substr(Length);
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code RawCoverageFilenamesReader::read() {
+Error RawCoverageFilenamesReader::read() {
   uint64_t NumFilenames;
   if (auto Err = readSize(NumFilenames))
     return Err;
   for (size_t I = 0; I < NumFilenames; ++I) {
     StringRef Filename;
     if (auto Err = readString(Filename))
       return Err;
     Filenames.push_back(Filename);
   }
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code RawCoverageMappingReader::decodeCounter(unsigned Value,
-                                                        Counter &C) {
+Error RawCoverageMappingReader::decodeCounter(unsigned Value, Counter &C) {
   auto Tag = Value & Counter::EncodingTagMask;
   switch (Tag) {
   case Counter::Zero:
     C = Counter::getZero();
-    return std::error_code();
+    return Error::success();
   case Counter::CounterValueReference:
     C = Counter::getCounter(Value >> Counter::EncodingTagBits);
-    return std::error_code();
+    return Error::success();
   default:
     break;
   }
   Tag -= Counter::Expression;
   switch (Tag) {
   case CounterExpression::Subtract:
   case CounterExpression::Add: {
     auto ID = Value >> Counter::EncodingTagBits;
     if (ID >= Expressions.size())
-      return coveragemap_error::malformed;
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
     Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
     C = Counter::getExpression(ID);
     break;
   }
   default:
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
   }
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code RawCoverageMappingReader::readCounter(Counter &C) {
+Error 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 std::error_code();
+  return Error::success();
 }
 
 static const unsigned EncodingExpansionRegionBit = 1
                                                    << Counter::EncodingTagBits;
 
 /// \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.
-std::error_code RawCoverageMappingReader::readMappingRegionsSubArray(
+Error RawCoverageMappingReader::readMappingRegionsSubArray(
     std::vector<CounterMappingRegion> &MappingRegions, unsigned InferredFileID,
     size_t NumFileIDs) {
   uint64_t NumRegions;
   if (auto Err = readSize(NumRegions))
     return Err;
   unsigned LineStart = 0;
   for (size_t I = 0; I < NumRegions; ++I) {
     Counter C;
if (Tag != Counter::Zero) {
         return Err;
     } else {
       // Is it an expansion region?
       if (EncodedCounterAndRegion & EncodingExpansionRegionBit) {
         Kind = CounterMappingRegion::ExpansionRegion;
         ExpandedFileID = EncodedCounterAndRegion >>
                          Counter::EncodingCounterTagAndExpansionRegionTagBits;
         if (ExpandedFileID >= NumFileIDs)
-          return coveragemap_error::malformed;
+          return make_error<CoverageMapError>(coveragemap_error::malformed);
       } else {
         switch (EncodedCounterAndRegion >>
                 Counter::EncodingCounterTagAndExpansionRegionTagBits) {
         case CounterMappingRegion::CodeRegion:
           // Don't do anything when we have a code region with a zero counter.
           break;
         case CounterMappingRegion::SkippedRegion:
           Kind = CounterMappingRegion::SkippedRegion;
           break;
         default:
-          return coveragemap_error::malformed;
+          return make_error<CoverageMapError>(coveragemap_error::malformed);
         }
       }
     }
 
     // Read the source range.
     uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
     if (auto Err =
             readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max()))
       return Err;
     if (auto Err = readULEB128(ColumnStart))
       return Err;
     if (ColumnStart > std::numeric_limits<unsigned>::max())
-      return coveragemap_error::malformed;
+      return make_error<CoverageMapError>(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()))
       return Err;
     LineStart += LineStartDelta;
     // Adjust the column locations for the empty regions that are supposed to
     // cover whole lines. Those regions should be encoded with the
     // column range (1 -> std::numeric_limits<unsigned>::max()), but because
DEBUG({
         CounterMappingContext(Expressions).dump(C, dbgs());
       dbgs() << "\n";
     });
 
     MappingRegions.push_back(CounterMappingRegion(
         C, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
         LineStart + NumLines, ColumnEnd, Kind));
   }
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code RawCoverageMappingReader::read() {
+Error RawCoverageMappingReader::read() {
 
   // Read the virtual file mapping.
   llvm::SmallVector<unsigned, 8> VirtualFileMapping;
   uint64_t NumFileMappings;
   if (auto Err = readSize(NumFileMappings))
     return Err;
   for (size_t I = 0; I < NumFileMappings; ++I) {
     uint64_t FilenameIndex;
for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S; ++Pass) {
     for (auto &R : MappingRegions) {
       if (FileIDExpansionRegionMapping[R.FileID]) {
         FileIDExpansionRegionMapping[R.FileID]->Count = R.Count;
         FileIDExpansionRegionMapping[R.FileID] = nullptr;
       }
     }
   }
 
-  return std::error_code();
+  return Error::success();
 }
 
-std::error_code InstrProfSymtab::create(SectionRef &Section) {
-  if (auto Err = Section.getContents(Data))
-    return Err;
+Error InstrProfSymtab::create(SectionRef &Section) {
+  if (auto EC = Section.getContents(Data))
+    return errorCodeToError(EC);
   Address = Section.getAddress();
-  return std::error_code();
+  return Error::success();
 }
 
 StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
   if (Pointer < Address)
     return StringRef();
   auto Offset = Pointer - Address;
   if (Offset + Size > Data.size())
     return StringRef();
   return Data.substr(Pointer - Address, Size);
 }
 
 namespace {
 struct CovMapFuncRecordReader {
   // The interface to read coverage mapping function records for
   // 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 std::error_code readFunctionRecords(const char *&Buf,
-                                              const char *End) = 0;
+  virtual Error readFunctionRecords(const char *&Buf, const char *End) = 0;
   virtual ~CovMapFuncRecordReader() {}
   template <class IntPtrT, support::endianness Endian>
-  static ErrorOr<std::unique_ptr<CovMapFuncRecordReader>>
+  static Expected<std::unique_ptr<CovMapFuncRecordReader>>
   get(coverage::CovMapVersion Version, InstrProfSymtab &P,
       std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
       std::vector<StringRef> &F);
 };
 
 // A class for reading coverage mapping function records for a module.
 template <coverage::CovMapVersion Version, class IntPtrT,
           support::endianness Endian>

 public:
   VersionedCovMapFuncRecordReader(
       InstrProfSymtab &P,
       std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
       std::vector<StringRef> &F)
       : ProfileNames(P), Filenames(F), Records(R) {}
   ~VersionedCovMapFuncRecordReader() override {}
 
-  std::error_code readFunctionRecords(const char *&Buf,
-                                      const char *End) override {
+  Error readFunctionRecords(const char *&Buf, const char *End) override {
     using namespace support;
     if (Buf + sizeof(CovMapHeader) > End)
-      return coveragemap_error::malformed;
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
     auto CovHeader = reinterpret_cast<const coverage::CovMapHeader *>(Buf);
     uint32_t NRecords = CovHeader->getNRecords<Endian>();
     uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>();
     uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>();
     assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version);
     Buf = reinterpret_cast<const char *>(CovHeader + 1);
 
     // Skip past the function records, saving the start and end for later.
     const char *FunBuf = Buf;
     Buf += NRecords * sizeof(FuncRecordType);
     const char *FunEnd = Buf;
 
     // Get the filenames.
     if (Buf + FilenamesSize > End)
-      return coveragemap_error::malformed;
+      return make_error<CoverageMapError>(coveragemap_error::malformed);
     size_t FilenamesBegin = Filenames.size();
     RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize), Filenames);
     if (auto Err = Reader.read())
       return Err;
     Buf += FilenamesSize;
 
     // We'll read the coverage mapping records in the loop below.
     const char *CovBuf = Buf;
     Buf += CoverageSize;
     const char *CovEnd = Buf;
 
     if (Buf > End)
-      return coveragemap_error::malformed;
+      return make_error<CoverageMapError>(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);
 
     auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf);
     while ((const char *)CFR < FunEnd) {
       // Read the function information
       uint32_t DataSize = CFR->template getDataSize<Endian>();
       uint64_t FuncHash = CFR->template getFuncHash<Endian>();
 
       // Now use that to read the coverage data.
       if (CovBuf + DataSize > CovEnd)
-        return coveragemap_error::malformed;
+        return make_error<CoverageMapError>(coveragemap_error::malformed);
       auto Mapping = StringRef(CovBuf, DataSize);
       CovBuf += DataSize;
 
       // Ignore this record if we already have a record that points to the same
       // function name. This is useful to ignore the redundant records for the
       // functions with ODR linkage.
       NameRefType NameRef = CFR->template getFuncNameRef<Endian>();
       if (!UniqueFunctionMappingData.insert(NameRef).second) {
         CFR++;
         continue;
       }
 
       StringRef FuncName;
-      if (std::error_code EC =
-              CFR->template getFuncName<Endian>(ProfileNames, FuncName))
-        return EC;
+      if (Error E = CFR->template getFuncName<Endian>(ProfileNames, FuncName))
+        return E;
       Records.push_back(BinaryCoverageReader::ProfileMappingRecord(
           Version, FuncName, FuncHash, Mapping, FilenamesBegin,
           Filenames.size() - FilenamesBegin));
       CFR++;
     }
-    return std::error_code();
+    return Error::success();
   }
 };
 } // end anonymous namespace
 
 template <class IntPtrT, support::endianness Endian>
-ErrorOr<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
+Expected<std::unique_ptr<CovMapFuncRecordReader>> CovMapFuncRecordReader::get(
     coverage::CovMapVersion Version, InstrProfSymtab &P,
     std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
     std::vector<StringRef> &F) {
   using namespace coverage;
   switch (Version) {
   case CovMapVersion::Version1:
     return llvm::make_unique<VersionedCovMapFuncRecordReader<
         CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F);
   case CovMapVersion::Version2:
     // Decompress the name data.
-    if (auto EC = P.create(P.getNameData()))
-      return EC;
+    if (Error E = P.create(P.getNameData()))
+      return std::move(E);
     return llvm::make_unique<VersionedCovMapFuncRecordReader<
         CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F);
   }
   llvm_unreachable("Unsupported version");
 }
 
 template <typename T, support::endianness Endian>
-static std::error_code readCoverageMappingData(
+static Error readCoverageMappingData(
     InstrProfSymtab &ProfileNames, StringRef Data,
     std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
     std::vector<StringRef> &Filenames) {
   using namespace coverage;
   // Read the records in the coverage data section.
   auto CovHeader =
       reinterpret_cast<const coverage::CovMapHeader *>(Data.data());
   CovMapVersion Version = (CovMapVersion)CovHeader->getVersion<Endian>();
   if (Version > coverage::CovMapVersion::CurrentVersion)
-    return coveragemap_error::unsupported_version;
-  ErrorOr<std::unique_ptr<CovMapFuncRecordReader>> ReaderErrorOr =
+    return make_error<CoverageMapError>(coveragemap_error::unsupported_version);
+  Expected<std::unique_ptr<CovMapFuncRecordReader>> ReaderExpected =
       CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames, Records,
                                              Filenames);
-  if (auto EC = ReaderErrorOr.getError())
-    return EC;
-  auto Reader = std::move(ReaderErrorOr.get());
+  if (Error E = ReaderExpected.takeError())
+    return E;
+  auto Reader = std::move(ReaderExpected.get());
   for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf < End;) {
-    if (std::error_code EC = Reader->readFunctionRecords(Buf, End))
-      return EC;
+    if (Error E = Reader->readFunctionRecords(Buf, End))
+      return E;
   }
-  return std::error_code();
+  return Error::success();
 }
 static const char *TestingFormatMagic = "llvmcovmtestdata";
 
-static std::error_code loadTestingFormat(StringRef Data,
-                                         InstrProfSymtab &ProfileNames,
-                                         StringRef &CoverageMapping,
-                                         uint8_t &BytesInAddress,
-                                         support::endianness &Endian) {
+static Error loadTestingFormat(StringRef Data, InstrProfSymtab &ProfileNames,
   BytesInAddress = 8;
   Endian = support::endianness::little;
 
   Data = Data.substr(StringRef(TestingFormatMagic).size());
   if (Data.size() < 1)
-    return coveragemap_error::truncated;
+    return make_error<CoverageMapError>(coveragemap_error::truncated);
   unsigned N = 0;
   auto ProfileNamesSize =
       decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
   if (N > Data.size())
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
   if (Data.size() < 1)
-    return coveragemap_error::truncated;
+    return make_error<CoverageMapError>(coveragemap_error::truncated);
   N = 0;
   uint64_t Address =
       decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
   if (N > Data.size())
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
   Data = Data.substr(N);
   if (Data.size() < ProfileNamesSize)
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
   ProfileNames.create(Data.substr(0, ProfileNamesSize), Address);
   CoverageMapping = Data.substr(ProfileNamesSize);
-  return std::error_code();
+  return Error::success();
 }
 
-static ErrorOr<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
+static Expected<SectionRef> lookupSection(ObjectFile &OF, StringRef Name) {
   StringRef FoundName;
   for (const auto &Section : OF.sections()) {
     if (auto EC = Section.getName(FoundName))
-      return EC;
+      return errorCodeToError(EC);
     if (FoundName == Name)
       return Section;
   }
-  return coveragemap_error::no_data_found;
+  return make_error<CoverageMapError>(coveragemap_error::no_data_found);
 }
 
-static std::error_code
-loadBinaryFormat(MemoryBufferRef ObjectBuffer, InstrProfSymtab &ProfileNames,
-                 StringRef &CoverageMapping, uint8_t &BytesInAddress,
+static Error loadBinaryFormat(MemoryBufferRef ObjectBuffer,
+                              InstrProfSymtab &ProfileNames,
+                              StringRef &CoverageMapping,
+                              uint8_t &BytesInAddress,
                               support::endianness &Endian, StringRef Arch) {
   auto BinOrErr = object::createBinary(ObjectBuffer);
   if (!BinOrErr)
-    return errorToErrorCode(BinOrErr.takeError());
+    return 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 (std::error_code EC = ObjectFileOrErr.getError())
-      return EC;
+    if (auto EC = ObjectFileOrErr.getError())
+      return errorCodeToError(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 object_error::arch_not_found;
+      return errorCodeToError(object_error::arch_not_found);
   } else
     // We can only handle object files.
-    return coveragemap_error::malformed;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
 
   // The coverage uses native pointer sizes for the object it's written in.
   BytesInAddress = OF->getBytesInAddress();
   Endian = OF->isLittleEndian() ? support::endianness::little
                                 : support::endianness::big;
 
   // Look for the sections that we are interested in.
   auto NamesSection = lookupSection(*OF, getInstrProfNameSectionName(false));
-  if (auto EC = NamesSection.getError())
-    return EC;
+  if (auto E = NamesSection.takeError())
+    return E;
   auto CoverageSection =
       lookupSection(*OF, getInstrProfCoverageSectionName(false));
-  if (auto EC = CoverageSection.getError())
-    return EC;
+  if (auto E = CoverageSection.takeError())
+    return E;
 
   // Get the contents of the given sections.
-  if (std::error_code EC = CoverageSection->getContents(CoverageMapping))
-    return EC;
-  if (std::error_code EC = ProfileNames.create(*NamesSection))
-    return EC;
+  if (auto EC = CoverageSection->getContents(CoverageMapping))
+    return errorCodeToError(EC);
+  if (Error E = ProfileNames.create(*NamesSection))
+    return E;
 
-  return std::error_code();
+  return Error::success();
 }
 
-ErrorOr<std::unique_ptr<BinaryCoverageReader>>
+Expected<std::unique_ptr<BinaryCoverageReader>>
 BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
                              StringRef Arch) {
   std::unique_ptr<BinaryCoverageReader> Reader(new BinaryCoverageReader());
 
   StringRef Coverage;
   uint8_t BytesInAddress;
   support::endianness Endian;
-  std::error_code EC;
+  Error E;
+  consumeError(std::move(E));
   if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
     // This is a special format used for testing.
-    EC = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames,
-                           Coverage, BytesInAddress, Endian);
+    E = loadTestingFormat(ObjectBuffer->getBuffer(), Reader->ProfileNames,
   else
-    EC = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames,
-                          Coverage, BytesInAddress, Endian, Arch);
-  if (EC)
-    return EC;
+    E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(), Reader->ProfileNames,
+  if (E)
+    return std::move(E);
 
   if (BytesInAddress == 4 && Endian == support::endianness::little)
-    EC = readCoverageMappingData<uint32_t, support::endianness::little>(
+    E = readCoverageMappingData<uint32_t, support::endianness::little>(
         Reader->ProfileNames, Coverage, Reader->MappingRecords,
         Reader->Filenames);
   else if (BytesInAddress == 4 && Endian == support::endianness::big)
-    EC = readCoverageMappingData<uint32_t, support::endianness::big>(
+    E = readCoverageMappingData<uint32_t, support::endianness::big>(
         Reader->ProfileNames, Coverage, Reader->MappingRecords,
         Reader->Filenames);
   else if (BytesInAddress == 8 && Endian == support::endianness::little)
-    EC = readCoverageMappingData<uint64_t, support::endianness::little>(
+    E = readCoverageMappingData<uint64_t, support::endianness::little>(
         Reader->ProfileNames, Coverage, Reader->MappingRecords,
         Reader->Filenames);
   else if (BytesInAddress == 8 && Endian == support::endianness::big)
-    EC = readCoverageMappingData<uint64_t, support::endianness::big>(
+    E = readCoverageMappingData<uint64_t, support::endianness::big>(
         Reader->ProfileNames, Coverage, Reader->MappingRecords,
         Reader->Filenames);
   else
-    return coveragemap_error::malformed;
-  if (EC)
-    return EC;
+    return make_error<CoverageMapError>(coveragemap_error::malformed);
+  if (E)
+    return std::move(E);
   return std::move(Reader);
 }
 
-std::error_code
-BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
+Error BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
   if (CurrentRecord >= MappingRecords.size())
-    return coveragemap_error::eof;
+    return make_error<CoverageMapError>(coveragemap_error::eof);
 
   FunctionsFilenames.clear();
   Expressions.clear();
   MappingRegions.clear();
   auto &R = MappingRecords[CurrentRecord];
   RawCoverageMappingReader Reader(
       R.CoverageMapping,
       makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize),
       FunctionsFilenames, Expressions, MappingRegions);
   if (auto Err = Reader.read())
     return Err;
 
   Record.FunctionName = R.FunctionName;
   Record.FunctionHash = R.FunctionHash;
   Record.Filenames = FunctionsFilenames;
   Record.Expressions = Expressions;
   Record.MappingRegions = MappingRegions;
 
   ++CurrentRecord;
-  return std::error_code();
+  return Error::success();
 }

lib/ProfileData/InstrProf.cpp

 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
-#include "llvm/Support/ManagedStatic.h"
 
 using namespace llvm;
 
 namespace {
-class InstrProfErrorCategoryType : public std::error_category {
-  const char *name() const LLVM_NOEXCEPT override { return "llvm.instrprof"; }
-  std::string message(int IE) const override {
-    instrprof_error E = static_cast<instrprof_error>(IE);
-    switch (E) {
-    case instrprof_error::success:
-      return "Success";
-    case instrprof_error::eof:
-      return "End of File";
-    case instrprof_error::unrecognized_format:
-      return "Unrecognized instrumentation profile encoding format";
-    case instrprof_error::bad_magic:
-      return "Invalid instrumentation profile data (bad magic)";
-    case instrprof_error::bad_header:
-      return "Invalid instrumentation profile data (file header is corrupt)";
-    case instrprof_error::unsupported_version:
-      return "Unsupported instrumentation profile format version";
-    case instrprof_error::unsupported_hash_type:
-      return "Unsupported instrumentation profile hash type";
-    case instrprof_error::too_large:
-      return "Too much profile data";
-    case instrprof_error::truncated:
-      return "Truncated profile data";
-    case instrprof_error::malformed:
-      return "Malformed instrumentation profile data";
-    case instrprof_error::unknown_function:
-      return "No profile data available for function";
-    case instrprof_error::hash_mismatch:
-      return "Function control flow change detected (hash mismatch)";
-    case instrprof_error::count_mismatch:
-      return "Function basic block count change detected (counter mismatch)";
-    case instrprof_error::counter_overflow:
-      return "Counter overflow";
-    case instrprof_error::value_site_count_mismatch:
-      return "Function value site count change detected (counter mismatch)";
-    case instrprof_error::compress_failed:
-      return "Failed to compress data (zlib)";
-    case instrprof_error::uncompress_failed:
-      return "Failed to uncompress data (zlib)";
-    }
-    llvm_unreachable("A value of instrprof_error has no message.");
-  }
+std::string getInstrProfErrString(instrprof_error Err) {
+  switch (Err) {
+
+class InstrProfErrorCategoryType : public std::error_category {
+  const char *name() const LLVM_NOEXCEPT override { return "llvm.instrprof"; }
+  std::string message(int IE) const override {
+    return getInstrProfErrString(static_cast<instrprof_error>(IE));
+  }
 };
 } // end anonymous namespace
 
 static ManagedStatic<InstrProfErrorCategoryType> ErrorCategory;
 
 const std::error_category &llvm::instrprof_category() {
   return *ErrorCategory;
 }
void SoftInstrProfErrors::addError(instrprof_error IE) {
   case instrprof_error::value_site_count_mismatch:
     ++NumValueSiteCountMismatches;
     break;
   default:
     llvm_unreachable("Not a soft error");
   }
 }
 
+void InstrProfError::log(raw_ostream &OS) const { OS << message(); }
+
+std::string InstrProfError::message() const {
+  return getInstrProfErrString(Err);
+}
+
+template <> char EnumBasedError<instrprof_error>::ID = 0;
+
 std::string getPGOFuncName(StringRef RawFuncName,
                            GlobalValue::LinkageTypes Linkage,
                            StringRef FileName,
                            uint64_t Version LLVM_ATTRIBUTE_UNUSED) {
   return GlobalValue::getGlobalIdentifier(RawFuncName, Linkage, FileName);
 }
 
 // Return the PGOFuncName. This function has some special handling when called
for (Function &F : M) {
     const std::string &PGOFuncName = getPGOFuncName(F, InLTO);
     addFuncName(PGOFuncName);
     MD5FuncMap.emplace_back(Function::getGUID(PGOFuncName), &F);
   }
 
   finalizeSymtab();
 }
 
-std::error_code
-collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
+Error collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
                                 bool doCompression, std::string &Result) {
   assert(NameStrs.size() && "No name data to emit");
 
   uint8_t Header[16], *P = Header;
   std::string UncompressedNameStrings =
       join(NameStrs.begin(), NameStrs.end(), getInstrProfNameSeparator());
 
   assert(StringRef(UncompressedNameStrings)
                  .count(getInstrProfNameSeparator()) == (NameStrs.size() - 1) &&
          "PGO name is invalid (contains separator token)");
 
   unsigned EncLen = encodeULEB128(UncompressedNameStrings.length(), P);
   P += EncLen;
 
   auto WriteStringToResult = [&](size_t CompressedLen,
                                  const std::string &InputStr) {
     EncLen = encodeULEB128(CompressedLen, P);
     P += EncLen;
     char *HeaderStr = reinterpret_cast<char *>(&Header[0]);
     unsigned HeaderLen = P - &Header[0];
     Result.append(HeaderStr, HeaderLen);
     Result += InputStr;
-    return make_error_code(instrprof_error::success);
+    return Error::success();
   };
 
-  if (!doCompression)
+  if (!doCompression) {
     return WriteStringToResult(0, UncompressedNameStrings);
+  }
 
   SmallVector<char, 128> CompressedNameStrings;
   zlib::Status Success =
       zlib::compress(StringRef(UncompressedNameStrings), CompressedNameStrings,
                      zlib::BestSizeCompression);
 
   if (Success != zlib::StatusOK)
-    return make_error_code(instrprof_error::compress_failed);
+    return make_error<InstrProfError>(instrprof_error::compress_failed);
 
   return WriteStringToResult(
       CompressedNameStrings.size(),
       std::string(CompressedNameStrings.data(), CompressedNameStrings.size()));
 }
 
 StringRef getPGOFuncNameVarInitializer(GlobalVariable *NameVar) {
   auto *Arr = cast<ConstantDataArray>(NameVar->getInitializer());
   StringRef NameStr =
       Arr->isCString() ? Arr->getAsCString() : Arr->getAsString();
   return NameStr;
 }
 
-std::error_code
-collectPGOFuncNameStrings(const std::vector<GlobalVariable *> &NameVars,
+Error collectPGOFuncNameStrings(const std::vector<GlobalVariable *> &NameVars,
                                 std::string &Result, bool doCompression) {
   std::vector<std::string> NameStrs;
   for (auto *NameVar : NameVars) {
     NameStrs.push_back(getPGOFuncNameVarInitializer(NameVar));
   }
   return collectPGOFuncNameStrings(
       NameStrs, zlib::isAvailable() && doCompression, Result);
 }
 
-std::error_code readPGOFuncNameStrings(StringRef NameStrings,
-                                       InstrProfSymtab &Symtab) {
+Error readPGOFuncNameStrings(StringRef NameStrings, InstrProfSymtab &Symtab) {
   const uint8_t *P = reinterpret_cast<const uint8_t *>(NameStrings.data());
   const uint8_t *EndP = reinterpret_cast<const uint8_t *>(NameStrings.data() +
                                                           NameStrings.size());
   while (P < EndP) {
     uint32_t N;
     uint64_t UncompressedSize = decodeULEB128(P, &N);
     P += N;
     uint64_t CompressedSize = decodeULEB128(P, &N);
     P += N;
     bool isCompressed = (CompressedSize != 0);
     SmallString<128> UncompressedNameStrings;
     StringRef NameStrings;
     if (isCompressed) {
       StringRef CompressedNameStrings(reinterpret_cast<const char *>(P),
                                       CompressedSize);
       if (zlib::uncompress(CompressedNameStrings, UncompressedNameStrings,
                            UncompressedSize) != zlib::StatusOK)
-        return make_error_code(instrprof_error::uncompress_failed);
+        return make_error<InstrProfError>(instrprof_error::uncompress_failed);
       P += CompressedSize;
       NameStrings = StringRef(UncompressedNameStrings.data(),
                               UncompressedNameStrings.size());
     } else {
       NameStrings =
           StringRef(reinterpret_cast<const char *>(P), UncompressedSize);
       P += UncompressedSize;
     }
     // Now parse the name strings.
     SmallVector<StringRef, 0> Names;
     NameStrings.split(Names, getInstrProfNameSeparator());
     for (StringRef &Name : Names)
       Symtab.addFuncName(Name);
 
     while (P < EndP && *P == 0)
       P++;
   }
   Symtab.finalizeSymtab();
-  return make_error_code(instrprof_error::success);
+  return Error::success();
 }
 
 void InstrProfValueSiteRecord::merge(SoftInstrProfErrors &SIPE,
                                      InstrProfValueSiteRecord &Input,
                                      uint64_t Weight) {
   this->sortByTargetValues();
   Input.sortByTargetValues();
   auto I = ValueData.begin();
else
     return endian::readNext<T, big, unaligned>(D);
 }
 
 static std::unique_ptr<ValueProfData> allocValueProfData(uint32_t TotalSize) {
   return std::unique_ptr<ValueProfData>(new (::operator new(TotalSize))
                                             ValueProfData());
 }
 
-instrprof_error ValueProfData::checkIntegrity() {
+Error ValueProfData::checkIntegrity() {
   if (NumValueKinds > IPVK_Last + 1)
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
   // Total size needs to be mulltiple of quadword size.
   if (TotalSize % sizeof(uint64_t))
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
 
   ValueProfRecord *VR = getFirstValueProfRecord(this);
   for (uint32_t K = 0; K < this->NumValueKinds; K++) {
     if (VR->Kind > IPVK_Last)
-      return instrprof_error::malformed;
+      return make_error<InstrProfError>(instrprof_error::malformed);
     VR = getValueProfRecordNext(VR);
     if ((char *)VR - (char *)this > (ptrdiff_t)TotalSize)
-      return instrprof_error::malformed;
+      return make_error<InstrProfError>(instrprof_error::malformed);
   }
-  return instrprof_error::success;
+  return Error::success();
 }
 
-ErrorOr<std::unique_ptr<ValueProfData>>
+Expected<std::unique_ptr<ValueProfData>>
 ValueProfData::getValueProfData(const unsigned char *D,
                                 const unsigned char *const BufferEnd,
                                 support::endianness Endianness) {
   using namespace support;
   if (D + sizeof(ValueProfData) > BufferEnd)
-    return instrprof_error::truncated;
+    return make_error<InstrProfError>(instrprof_error::truncated);
 
   const unsigned char *Header = D;
   uint32_t TotalSize = swapToHostOrder<uint32_t>(Header, Endianness);
   if (D + TotalSize > BufferEnd)
-    return instrprof_error::too_large;
+    return make_error<InstrProfError>(instrprof_error::too_large);
 
   std::unique_ptr<ValueProfData> VPD = allocValueProfData(TotalSize);
   memcpy(VPD.get(), D, TotalSize);
   // Byte swap.
   VPD->swapBytesToHost(Endianness);
 
-  instrprof_error EC = VPD->checkIntegrity();
-  if (EC != instrprof_error::success)
-    return EC;
+  Error E = VPD->checkIntegrity();
+  if (E)
+    return std::move(E);
 
   return std::move(VPD);
 }
 
 void ValueProfData::swapBytesToHost(support::endianness Endianness) {
   using namespace support;
   if (Endianness == getHostEndianness())
     return;

lib/ProfileData/InstrProfReader.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ADT/STLExtras.h"
 #include <cassert>
 
 using namespace llvm;
 
-static ErrorOr<std::unique_ptr<MemoryBuffer>>
+static Expected<std::unique_ptr<MemoryBuffer>>
 setupMemoryBuffer(std::string Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
       MemoryBuffer::getFileOrSTDIN(Path);
   if (std::error_code EC = BufferOrErr.getError())
-    return EC;
+    return errorCodeToError(EC);
   return std::move(BufferOrErr.get());
 }
 
-static std::error_code initializeReader(InstrProfReader &Reader) {
+static Error initializeReader(InstrProfReader &Reader) {
   return Reader.readHeader();
 }
 
-ErrorOr<std::unique_ptr<InstrProfReader>>
+Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(std::string Path) {
   // Set up the buffer to read.
   auto BufferOrError = setupMemoryBuffer(Path);
-  if (std::error_code EC = BufferOrError.getError())
-    return EC;
+  if (Error E = BufferOrError.takeError())
+    return std::move(E);
   return InstrProfReader::create(std::move(BufferOrError.get()));
 }
 
-ErrorOr<std::unique_ptr<InstrProfReader>>
+Expected<std::unique_ptr<InstrProfReader>>
 InstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
   // Sanity check the buffer.
   if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
-    return instrprof_error::too_large;
+    return make_error<InstrProfError>(instrprof_error::too_large);
 
   std::unique_ptr<InstrProfReader> Result;
   // Create the reader.
   if (IndexedInstrProfReader::hasFormat(*Buffer))
     Result.reset(new IndexedInstrProfReader(std::move(Buffer)));
   else if (RawInstrProfReader64::hasFormat(*Buffer))
     Result.reset(new RawInstrProfReader64(std::move(Buffer)));
   else if (RawInstrProfReader32::hasFormat(*Buffer))
     Result.reset(new RawInstrProfReader32(std::move(Buffer)));
   else if (TextInstrProfReader::hasFormat(*Buffer))
     Result.reset(new TextInstrProfReader(std::move(Buffer)));
   else
-    return instrprof_error::unrecognized_format;
+    return make_error<InstrProfError>(instrprof_error::unrecognized_format);
 
   // Initialize the reader and return the result.
-  if (std::error_code EC = initializeReader(*Result))
-    return EC;
+  if (Error E = initializeReader(*Result))
+    return std::move(E);
 
   return std::move(Result);
 }
 
-ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
+Expected<std::unique_ptr<IndexedInstrProfReader>>
 IndexedInstrProfReader::create(std::string Path) {
   // Set up the buffer to read.
   auto BufferOrError = setupMemoryBuffer(Path);
-  if (std::error_code EC = BufferOrError.getError())
-    return EC;
+  if (Error E = BufferOrError.takeError())
+    return std::move(E);
   return IndexedInstrProfReader::create(std::move(BufferOrError.get()));
 }
 
 
-ErrorOr<std::unique_ptr<IndexedInstrProfReader>>
+Expected<std::unique_ptr<IndexedInstrProfReader>>
 IndexedInstrProfReader::create(std::unique_ptr<MemoryBuffer> Buffer) {
   // Sanity check the buffer.
   if (Buffer->getBufferSize() > std::numeric_limits<unsigned>::max())
-    return instrprof_error::too_large;
+    return make_error<InstrProfError>(instrprof_error::too_large);
 
   // Create the reader.
   if (!IndexedInstrProfReader::hasFormat(*Buffer))
-    return instrprof_error::bad_magic;
+    return make_error<InstrProfError>(instrprof_error::bad_magic);
   auto Result = llvm::make_unique<IndexedInstrProfReader>(std::move(Buffer));
 
   // Initialize the reader and return the result.
-  if (std::error_code EC = initializeReader(*Result))
-    return EC;
+  if (Error E = initializeReader(*Result))
+    return std::move(E);
 
   return std::move(Result);
 }
 
 void InstrProfIterator::Increment() {
-  if (Reader->readNextRecord(Record))
+  if (auto E = Reader->readNextRecord(Record)) {
+    instrprof_error Err = InstrProfError::take(std::move(E));
+    if (Err != instrprof_error::eof)
+      llvm_unreachable("Unexpected error in profile iterator");
     *this = InstrProfIterator();
   }
+}
 
 bool TextInstrProfReader::hasFormat(const MemoryBuffer &Buffer) {
   // Verify that this really looks like plain ASCII text by checking a
   // 'reasonable' number of characters (up to profile magic size).
   size_t count = std::min(Buffer.getBufferSize(), sizeof(uint64_t));
   StringRef buffer = Buffer.getBufferStart();
   return count == 0 ||
          std::all_of(buffer.begin(), buffer.begin() + count,
                      [](char c) { return ::isprint(c) || ::isspace(c); });
 }
 
 // Read the profile variant flag from the header: ":FE" means this is a FE
 // generated profile. ":IR" means this is an IR level profile. Other strings
 // with a leading ':' will be reported an error format.
-std::error_code TextInstrProfReader::readHeader() {
+Error TextInstrProfReader::readHeader() {
   Symtab.reset(new InstrProfSymtab());
   bool IsIRInstr = false;
   if (!Line->startswith(":")) {
     IsIRLevelProfile = false;
     return success();
   }
   StringRef Str = (Line)->substr(1);
   if (Str.equals_lower("ir"))
     IsIRInstr = true;
   else if (Str.equals_lower("fe"))
     IsIRInstr = false;
   else
-    return instrprof_error::bad_header;
+    return error(instrprof_error::bad_header);
 
   ++Line;
   IsIRLevelProfile = IsIRInstr;
   return success();
 }
 
-std::error_code
+Error
 TextInstrProfReader::readValueProfileData(InstrProfRecord &Record) {
 
 #define CHECK_LINE_END(Line)                                                   \
   if (Line.is_at_end())                                                        \
     return error(instrprof_error::truncated);
 #define READ_NUM(Str, Dst)                                                     \
   if ((Str).getAsInteger(10, (Dst)))                                           \
     return error(instrprof_error::malformed);
#define VP_READ_ADVANCE(Val)                                                   \
   }
   return success();
 
 #undef CHECK_LINE_END
 #undef READ_NUM
 #undef VP_READ_ADVANCE
 }
 
-std::error_code TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
+Error TextInstrProfReader::readNextRecord(InstrProfRecord &Record) {
   // Skip empty lines and comments.
   while (!Line.is_at_end() && (Line->empty() || Line->startswith("#")))
     ++Line;
   // If we hit EOF while looking for a name, we're done.
   if (Line.is_at_end()) {
     Symtab->finalizeSymtab();
     return error(instrprof_error::eof);
   }
if (Line.is_at_end())
       return error(instrprof_error::truncated);
     uint64_t Count;
     if ((Line++)->getAsInteger(10, Count))
       return error(instrprof_error::malformed);
     Record.Counts.push_back(Count);
   }
 
   // Check if value profile data exists and read it if so.
-  if (std::error_code EC = readValueProfileData(Record))
-    return EC;
+  if (Error E = readValueProfileData(Record))
+    return E;
 
   // This is needed to avoid two pass parsing because llvm-profdata
   // does dumping while reading.
   Symtab->finalizeSymtab();
   return success();
 }
 
 template <class IntPtrT>
 bool RawInstrProfReader<IntPtrT>::hasFormat(const MemoryBuffer &DataBuffer) {
   if (DataBuffer.getBufferSize() < sizeof(uint64_t))
     return false;
   uint64_t Magic =
     *reinterpret_cast<const uint64_t *>(DataBuffer.getBufferStart());
   return RawInstrProf::getMagic<IntPtrT>() == Magic ||
          sys::getSwappedBytes(RawInstrProf::getMagic<IntPtrT>()) == Magic;
 }
 
 template <class IntPtrT>
-std::error_code RawInstrProfReader<IntPtrT>::readHeader() {
+Error RawInstrProfReader<IntPtrT>::readHeader() {
   if (!hasFormat(*DataBuffer))
     return error(instrprof_error::bad_magic);
   if (DataBuffer->getBufferSize() < sizeof(RawInstrProf::Header))
     return error(instrprof_error::bad_header);
   auto *Header = reinterpret_cast<const RawInstrProf::Header *>(
       DataBuffer->getBufferStart());
   ShouldSwapBytes = Header->Magic != RawInstrProf::getMagic<IntPtrT>();
   return readHeader(*Header);
 }
 
 template <class IntPtrT>
-std::error_code
-RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
+Error RawInstrProfReader<IntPtrT>::readNextHeader(const char *CurrentPos) {
   const char *End = DataBuffer->getBufferEnd();
   // Skip zero padding between profiles.
   while (CurrentPos != End && *CurrentPos == 0)
     ++CurrentPos;
   // If there's nothing left, we're done.
   if (CurrentPos == End)
-    return instrprof_error::eof;
+    return make_error<InstrProfError>(instrprof_error::eof);
   // If there isn't enough space for another header, this is probably just
   // garbage at the end of the file.
   if (CurrentPos + sizeof(RawInstrProf::Header) > End)
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
   // The writer ensures each profile is padded to start at an aligned address.
   if (reinterpret_cast<size_t>(CurrentPos) % alignOf<uint64_t>())
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
   // The magic should have the same byte order as in the previous header.
   uint64_t Magic = *reinterpret_cast<const uint64_t *>(CurrentPos);
   if (Magic != swap(RawInstrProf::getMagic<IntPtrT>()))
-    return instrprof_error::bad_magic;
+    return make_error<InstrProfError>(instrprof_error::bad_magic);
 
   // There's another profile to read, so we need to process the header.
   auto *Header = reinterpret_cast<const RawInstrProf::Header *>(CurrentPos);
   return readHeader(*Header);
 }
 
 template <class IntPtrT>
-std::error_code
-RawInstrProfReader<IntPtrT>::createSymtab(InstrProfSymtab &Symtab) {
-  std::error_code EC = Symtab.create(StringRef(NamesStart, NamesSize));
-  if (EC)
-    return EC;
+Error RawInstrProfReader<IntPtrT>::createSymtab(InstrProfSymtab &Symtab) {
+  if (Error E = Symtab.create(StringRef(NamesStart, NamesSize)))
+    return error(std::move(E));
   for (const RawInstrProf::ProfileData<IntPtrT> *I = Data; I != DataEnd; ++I) {
     const IntPtrT FPtr = swap(I->FunctionPointer);
     if (!FPtr)
       continue;
     Symtab.mapAddress(FPtr, I->NameRef);
   }
   Symtab.finalizeSymtab();
   return success();
 }
 
 template <class IntPtrT>
-std::error_code
-RawInstrProfReader<IntPtrT>::readHeader(const RawInstrProf::Header &Header) {
+Error RawInstrProfReader<IntPtrT>::readHeader(
+    const RawInstrProf::Header &Header) {
   Version = swap(Header.Version);
   if (GET_VERSION(Version) != RawInstrProf::Version)
     return error(instrprof_error::unsupported_version);
 
   CountersDelta = swap(Header.CountersDelta);
   NamesDelta = swap(Header.NamesDelta);
   auto DataSize = swap(Header.DataSize);
   auto CountersSize = swap(Header.CountersSize);
Error RawInstrProfReader<IntPtrT>::readHeader(
   Data = reinterpret_cast<const RawInstrProf::ProfileData<IntPtrT> *>(
       Start + DataOffset);
   DataEnd = Data + DataSize;
   CountersStart = reinterpret_cast<const uint64_t *>(Start + CountersOffset);
   NamesStart = Start + NamesOffset;
   ValueDataStart = reinterpret_cast<const uint8_t *>(Start + ValueDataOffset);
 
   std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
-  if (auto EC = createSymtab(*NewSymtab.get()))
-    return EC;
+  if (Error E = createSymtab(*NewSymtab.get()))
+    return E;
 
   Symtab = std::move(NewSymtab);
   return success();
 }
 
 template <class IntPtrT>
-std::error_code RawInstrProfReader<IntPtrT>::readName(InstrProfRecord &Record) {
+Error RawInstrProfReader<IntPtrT>::readName(InstrProfRecord &Record) {
   Record.Name = getName(Data->NameRef);
   return success();
 }
 
 template <class IntPtrT>
-std::error_code RawInstrProfReader<IntPtrT>::readFuncHash(
-    InstrProfRecord &Record) {
+Error RawInstrProfReader<IntPtrT>::readFuncHash(InstrProfRecord &Record) {
   Record.Hash = swap(Data->FuncHash);
   return success();
 }
 
 template <class IntPtrT>
-std::error_code RawInstrProfReader<IntPtrT>::readRawCounts(
+Error RawInstrProfReader<IntPtrT>::readRawCounts(
     InstrProfRecord &Record) {
   uint32_t NumCounters = swap(Data->NumCounters);
   IntPtrT CounterPtr = Data->CounterPtr;
   if (NumCounters == 0)
     return error(instrprof_error::malformed);
 
   auto RawCounts = makeArrayRef(getCounter(CounterPtr), NumCounters);
   auto *NamesStartAsCounter = reinterpret_cast<const uint64_t *>(NamesStart);
for (uint64_t Count : RawCounts)
       Record.Counts.push_back(swap(Count));
   } else
     Record.Counts = RawCounts;
 
   return success();
 }
 
 template <class IntPtrT>
-std::error_code
-RawInstrProfReader<IntPtrT>::readValueProfilingData(InstrProfRecord &Record) {
+Error RawInstrProfReader<IntPtrT>::readValueProfilingData(
+    InstrProfRecord &Record) {
 
   Record.clearValueData();
   CurValueDataSize = 0;
   // Need to match the logic in value profile dumper code in compiler-rt:
   uint32_t NumValueKinds = 0;
   for (uint32_t I = 0; I < IPVK_Last + 1; I++)
     NumValueKinds += (Data->NumValueSites[I] != 0);
 
   if (!NumValueKinds)
     return success();
 
-  ErrorOr<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
+  Expected<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
       ValueProfData::getValueProfData(
           ValueDataStart, (const unsigned char *)DataBuffer->getBufferEnd(),
           getDataEndianness());
 
-  if (VDataPtrOrErr.getError())
-    return VDataPtrOrErr.getError();
+  if (Error E = VDataPtrOrErr.takeError())
+    return E;
 
   // Note that besides deserialization, this also performs the conversion for
   // indirect call targets.  The function pointers from the raw profile are
   // remapped into function name hashes.
   VDataPtrOrErr.get()->deserializeTo(Record, &Symtab->getAddrHashMap());
   CurValueDataSize = VDataPtrOrErr.get()->getSize();
   return success();
 }
 
 template <class IntPtrT>
-std::error_code
-RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
+Error RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
   if (atEnd())
     // At this point, ValueDataStart field points to the next header.
-    if (std::error_code EC = readNextHeader(getNextHeaderPos()))
-      return EC;
+    if (Error E = readNextHeader(getNextHeaderPos()))
+      return E;
 
   // Read name ad set it in Record.
-  if (std::error_code EC = readName(Record))
-    return EC;
+  if (Error E = readName(Record))
+    return E;
 
   // Read FuncHash and set it in Record.
-  if (std::error_code EC = readFuncHash(Record))
-    return EC;
+  if (Error E = readFuncHash(Record))
+    return E;
 
   // Read raw counts and set Record.
-  if (std::error_code EC = readRawCounts(Record))
-    return EC;
+  if (Error E = readRawCounts(Record))
+    return E;
 
   // Read value data and set Record.
-  if (std::error_code EC = readValueProfilingData(Record))
-    return EC;
+  if (Error E = readValueProfilingData(Record))
+    return E;
 
   // Iterate.
   advanceData();
   return success();
 }
 
 namespace llvm {
 template class RawInstrProfReader<uint32_t>;
 template class RawInstrProfReader<uint64_t>;
 }
 
 InstrProfLookupTrait::hash_value_type
 InstrProfLookupTrait::ComputeHash(StringRef K) {
   return IndexedInstrProf::ComputeHash(HashType, K);
 }
 
 typedef InstrProfLookupTrait::data_type data_type;
 typedef InstrProfLookupTrait::offset_type offset_type;
 
 bool InstrProfLookupTrait::readValueProfilingData(
     const unsigned char *&D, const unsigned char *const End) {
-  ErrorOr<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
+  Expected<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
       ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
 
-  if (VDataPtrOrErr.getError())
+  if (VDataPtrOrErr.takeError())
     return false;
 
   VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
   D += VDataPtrOrErr.get()->TotalSize;
 
   return true;
 }
 
if (GET_VERSION(FormatVersion) > IndexedInstrProf::ProfVersion::Version2 &&
       DataBuffer.clear();
       return data_type();
     }
   }
   return DataBuffer;
 }
 
 template <typename HashTableImpl>
-std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
+Error InstrProfReaderIndex<HashTableImpl>::getRecords(
     StringRef FuncName, ArrayRef<InstrProfRecord> &Data) {
   auto Iter = HashTable->find(FuncName);
   if (Iter == HashTable->end())
-    return instrprof_error::unknown_function;
+    return make_error<InstrProfError>(instrprof_error::unknown_function);
 
   Data = (*Iter);
   if (Data.empty())
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
 
-  return instrprof_error::success;
+  return Error::success();
 }
 
 template <typename HashTableImpl>
-std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
+Error InstrProfReaderIndex<HashTableImpl>::getRecords(
     ArrayRef<InstrProfRecord> &Data) {
   if (atEnd())
-    return instrprof_error::eof;
+    return make_error<InstrProfError>(instrprof_error::eof);
 
   Data = *RecordIterator;
 
   if (Data.empty())
-    return instrprof_error::malformed;
+    return make_error<InstrProfError>(instrprof_error::malformed);
 
-  return instrprof_error::success;
+  return Error::success();
 }
 
 template <typename HashTableImpl>
 InstrProfReaderIndex<HashTableImpl>::InstrProfReaderIndex(
     const unsigned char *Buckets, const unsigned char *const Payload,
     const unsigned char *const Base, IndexedInstrProf::HashT HashType,
     uint64_t Version) {
   FormatVersion = Version;
if (Version >= IndexedInstrProf::Version4) {
     using namespace IndexedInstrProf;
     this->Summary =
         llvm::make_unique<InstrProfSummary>(ProfileSummary::DefaultCutoffs);
     this->Summary->computeDetailedSummary();
     return Cur;
   }
 }
 
-std::error_code IndexedInstrProfReader::readHeader() {
+Error IndexedInstrProfReader::readHeader() {
   const unsigned char *Start =
       (const unsigned char *)DataBuffer->getBufferStart();
   const unsigned char *Cur = Start;
   if ((const unsigned char *)DataBuffer->getBufferEnd() - Cur < 24)
     return error(instrprof_error::truncated);
 
   using namespace support;
 
InstrProfSymtab &IndexedInstrProfReader::getSymtab() {
 
   std::unique_ptr<InstrProfSymtab> NewSymtab = make_unique<InstrProfSymtab>();
   Index->populateSymtab(*NewSymtab.get());
 
   Symtab = std::move(NewSymtab);
   return *Symtab.get();
 }
 
-ErrorOr<InstrProfRecord>
+Expected<InstrProfRecord>
 IndexedInstrProfReader::getInstrProfRecord(StringRef FuncName,
                                            uint64_t FuncHash) {
   ArrayRef<InstrProfRecord> Data;
-  std::error_code EC = Index->getRecords(FuncName, Data);
-  if (EC != instrprof_error::success)
-    return EC;
+  Error Err = Index->getRecords(FuncName, Data);
+  if (Err)
+    return std::move(Err);
   // Found it. Look for counters with the right hash.
   for (unsigned I = 0, E = Data.size(); I < E; ++I) {
     // Check for a match and fill the vector if there is one.
     if (Data[I].Hash == FuncHash) {
       return std::move(Data[I]);
     }
   }
   return error(instrprof_error::hash_mismatch);
 }
 
-std::error_code
-IndexedInstrProfReader::getFunctionCounts(StringRef FuncName, uint64_t FuncHash,
+Error IndexedInstrProfReader::getFunctionCounts(StringRef FuncName,
+                                                uint64_t FuncHash,
                                                 std::vector<uint64_t> &Counts) {
-  ErrorOr<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
-  if (std::error_code EC = Record.getError())
-    return EC;
+  Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName, FuncHash);
+  if (Error E = Record.takeError())
+    return error(std::move(E));
 
   Counts = Record.get().Counts;
   return success();
 }
 
-std::error_code IndexedInstrProfReader::readNextRecord(
-    InstrProfRecord &Record) {
+Error IndexedInstrProfReader::readNextRecord(InstrProfRecord &Record) {
   static unsigned RecordIndex = 0;
 
   ArrayRef<InstrProfRecord> Data;
 
-  std::error_code EC = Index->getRecords(Data);
-  if (EC != instrprof_error::success)
-    return error(EC);
+  Error E = Index->getRecords(Data);
+  if (E)
+    return error(std::move(E));
 
   Record = Data[RecordIndex++];
   if (RecordIndex >= Data.size()) {
     Index->advanceToNextKey();
     RecordIndex = 0;
   }
   return success();
 }

lib/ProfileData/InstrProfWriter.cpp

 void InstrProfWriter::setValueProfDataEndianness(
     support::endianness Endianness) {
   InfoObj->ValueProfDataEndianness = Endianness;
 }
 void InstrProfWriter::setOutputSparse(bool Sparse) {
   this->Sparse = Sparse;
 }
 
-std::error_code InstrProfWriter::addRecord(InstrProfRecord &&I,
-                                           uint64_t Weight) {
+Error InstrProfWriter::addRecord(InstrProfRecord &&I, uint64_t Weight) {
   auto &ProfileDataMap = FunctionData[I.Name];
 
   bool NewFunc;
   ProfilingData::iterator Where;
   std::tie(Where, NewFunc) =
       ProfileDataMap.insert(std::make_pair(I.Hash, InstrProfRecord()));
   InstrProfRecord &Dest = Where->second;
 
   if (NewFunc) {
     // We've never seen a function with this name and hash, add it.
     Dest = std::move(I);
     // Fix up the name to avoid dangling reference.
     Dest.Name = FunctionData.find(Dest.Name)->getKey();
     if (Weight > 1)
       Dest.scale(Weight);
   } else {
     // We're updating a function we've seen before.
     Dest.merge(I, Weight);
   }
 
   Dest.sortValueData();
 
-  return Dest.getError();
+  return Dest.takeError();
 }
 
 bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) {
   if (!Sparse)
     return true;
   for (const auto &Func : PD) {
     const InstrProfRecord &IPR = Func.second;
     if (std::any_of(IPR.Counts.begin(), IPR.Counts.end(),

lib/Transforms/Instrumentation/InstrProfiling.cpp

 
 void InstrProfiling::emitNameData() {
   std::string UncompressedData;
 
   if (ReferencedNames.empty())
     return;
 
   std::string CompressedNameStr;
-  if (auto EC = collectPGOFuncNameStrings(ReferencedNames, CompressedNameStr,
+  if (Error E = collectPGOFuncNameStrings(ReferencedNames, CompressedNameStr,
                                           DoNameCompression)) {
-    llvm::report_fatal_error(EC.message(), false);
+    llvm::report_fatal_error(toString(std::move(E)), false);
   }
 
   auto &Ctx = M->getContext();
   auto *NamesVal = llvm::ConstantDataArray::getString(
       Ctx, StringRef(CompressedNameStr), false);
   NamesVar = new llvm::GlobalVariable(*M, NamesVal->getType(), true,
                                       llvm::GlobalValue::PrivateLinkage,
                                       NamesVal, getInstrProfNamesVarName());

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

   llvm_unreachable("Cannot find the unknown count edge");
 }
 
 // Read the profile from ProfileFileName and assign the value to the
 // instrumented BB and the edges. This function also updates ProgramMaxCount.
 // Return true if the profile are successfully read, and false on errors.
 bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader) {
   auto &Ctx = M->getContext();
-  ErrorOr<InstrProfRecord> Result =
+  Expected<InstrProfRecord> Result =
       PGOReader->getInstrProfRecord(FuncInfo.FuncName, FuncInfo.FunctionHash);
-  if (std::error_code EC = Result.getError()) {
-    if (EC == instrprof_error::unknown_function)
-      NumOfPGOMissing++;
-    else if (EC == instrprof_error::hash_mismatch ||
-             EC == llvm::instrprof_error::malformed)
-      NumOfPGOMismatch++;
-
-    std::string Msg = EC.message() + std::string(" ") + F.getName().str();
-    Ctx.diagnose(
-        DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
+  if (Error E = Result.takeError()) {
+    handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
+      auto Err = IPE.get();
+      if (Err == instrprof_error::unknown_function)
+        NumOfPGOMissing++;
+      else if (Err == instrprof_error::hash_mismatch ||
+               Err == llvm::instrprof_error::malformed)
+        NumOfPGOMismatch++;
+
+      std::string Msg = IPE.message() + std::string(" ") + F.getName().str();
+      Ctx.diagnose(
+          DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
+    });
     return false;
   }
   ProfileRecord = std::move(Result.get());
   std::vector<uint64_t> &CountFromProfile = ProfileRecord.Counts;
 
   NumOfPGOFunc++;
   DEBUG(dbgs() << CountFromProfile.size() << " counts\n");
   uint64_t ValueSum = 0;

 static bool annotateAllFunctions(
     Module &M, StringRef ProfileFileName,
     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI) {
   DEBUG(dbgs() << "Read in profile counters: ");
   auto &Ctx = M.getContext();
   // Read the counter array from file.
   auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName);
-  if (std::error_code EC = ReaderOrErr.getError()) {
-    Ctx.diagnose(
-        DiagnosticInfoPGOProfile(ProfileFileName.data(), EC.message()));
+  if (Error E = ReaderOrErr.takeError()) {
+    handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
+      Ctx.diagnose(
+          DiagnosticInfoPGOProfile(ProfileFileName.data(), IPE.message()));
+    });
     return false;
   }
 
   std::unique_ptr<IndexedInstrProfReader> PGOReader =
       std::move(ReaderOrErr.get());
   if (!PGOReader) {
     Ctx.diagnose(DiagnosticInfoPGOProfile(ProfileFileName.data(),
                                           StringRef("Cannot get PGOReader")));

tools/llvm-cov/CodeCoverage.cpp

static bool modifiedTimeGT(StringRef LHS, StringRef RHS) {
   return LHSTime > RHSTime;
 }
 
 std::unique_ptr<CoverageMapping> CodeCoverageTool::load() {
   if (modifiedTimeGT(ObjectFilename, PGOFilename))
     errs() << "warning: profile data may be out of date - object is newer\n";
   auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
                                              CoverageArch);
-  if (std::error_code EC = CoverageOrErr.getError()) {
+  if (Error E = CoverageOrErr.takeError()) {
     colored_ostream(errs(), raw_ostream::RED)
-        << "error: Failed to load coverage: " << EC.message();
-    errs() << "\n";
+        << "error: Failed to load coverage: " << toString(std::move(E)) << "\n";
     return nullptr;
   }
   auto Coverage = std::move(CoverageOrErr.get());
   unsigned Mismatched = Coverage->getMismatchedCount();
   if (Mismatched) {
     colored_ostream(errs(), raw_ostream::RED)
         << "warning: " << Mismatched << " functions have mismatched data. ";
     errs() << "\n";

tools/llvm-profdata/llvm-profdata.cpp

static void exitWithError(const Twine &Message, StringRef Whence = "",
   if (!Whence.empty())
     errs() << Whence << ": ";
   errs() << Message << "\n";
   if (!Hint.empty())
     errs() << Hint << "\n";
   ::exit(1);
 }
 
-static void exitWithErrorCode(const std::error_code &Error,
-                              StringRef Whence = "") {
-  if (Error.category() == instrprof_category()) {
-    instrprof_error instrError = static_cast<instrprof_error>(Error.value());
+static void exitWithError(Error E, StringRef Whence = "") {
+  if (E.isA<InstrProfError>()) {
+    handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
+      instrprof_error instrError = IPE.get();
       if (instrError == instrprof_error::unrecognized_format) {
         // Hint for common error of forgetting -sample for sample profiles.
-      exitWithError(Error.message(), Whence,
+        exitWithError(IPE.message(), Whence,
                       "Perhaps you forgot to use the -sample option?");
       }
+    });
   }
-  exitWithError(Error.message(), Whence);
+
+  exitWithError(toString(std::move(E)), Whence);
+}
+
+static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
+  exitWithError(EC.message(), Whence);
 }
 
 namespace {
 enum ProfileKinds { instr, sample };
 }
 
-static void handleMergeWriterError(std::error_code &Error,
-                                   StringRef WhenceFile = "",
+static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
                                    StringRef WhenceFunction = "",
                                    bool ShowHint = true) {
   if (!WhenceFile.empty())
     errs() << WhenceFile << ": ";
   if (!WhenceFunction.empty())
     errs() << WhenceFunction << ": ";
-  errs() << Error.message() << "\n";
+
+  auto IPE = instrprof_error::success;
+  E = handleErrors(std::move(E),
+                   [&IPE](std::unique_ptr<InstrProfError> E) -> Error {
+                     IPE = E->get();
+                     return Error(std::move(E));
+                   });
+  errs() << toString(std::move(E)) << "\n";
 
   if (ShowHint) {
     StringRef Hint = "";
-    if (Error.category() == instrprof_category()) {
-      instrprof_error instrError = static_cast<instrprof_error>(Error.value());
-      switch (instrError) {
+    if (IPE != instrprof_error::success) {
+      switch (IPE) {
       case instrprof_error::hash_mismatch:
       case instrprof_error::count_mismatch:
       case instrprof_error::value_site_count_mismatch:
         Hint = "Make sure that all profile data to be merged is generated "
                "from the same binary.";
         break;
       default:
         break;
if (OutputFormat != PF_Binary && OutputFormat != PF_Text)
     exitWithError("Unknown format is specified.");
 
   std::error_code EC;
   raw_fd_ostream Output(OutputFilename.data(), EC, sys::fs::F_None);
   if (EC)
     exitWithErrorCode(EC, OutputFilename);
 
   InstrProfWriter Writer(OutputSparse);
-  SmallSet<std::error_code, 4> WriterErrorCodes;
+  SmallSet<instrprof_error, 4> WriterErrorCodes;
   for (const auto &Input : Inputs) {
     auto ReaderOrErr = InstrProfReader::create(Input.Filename);
-    if (std::error_code ec = ReaderOrErr.getError())
-      exitWithErrorCode(ec, Input.Filename);
+    if (Error E = ReaderOrErr.takeError())
+      exitWithError(std::move(E), Input.Filename);
 
     auto Reader = std::move(ReaderOrErr.get());
     bool IsIRProfile = Reader->isIRLevelProfile();
     if (Writer.setIsIRLevelProfile(IsIRProfile))
       exitWithError("Merge IR generated profile with Clang generated profile.");
 
     for (auto &I : *Reader) {
-      if (std::error_code EC = Writer.addRecord(std::move(I), Input.Weight)) {
+      if (Error E = Writer.addRecord(std::move(I), Input.Weight)) {
         // Only show hint the first time an error occurs.
-        bool firstTime = WriterErrorCodes.insert(EC).second;
-        handleMergeWriterError(EC, Input.Filename, I.Name, firstTime);
+        instrprof_error IPE = InstrProfError::take(std::move(E));
+        bool firstTime = WriterErrorCodes.insert(IPE).second;
+        handleMergeWriterError(make_error<InstrProfError>(IPE), Input.Filename,
+                               I.Name, firstTime);
       }
     }
     if (Reader->hasError())
-      exitWithErrorCode(Reader->getError(), Input.Filename);
+      exitWithError(Reader->getError(), Input.Filename);
   }
   if (OutputFormat == PF_Text)
     Writer.writeText(Output);
   else
     Writer.write(Output);
 }
 
 static sampleprof::SampleProfileFormat FormatMap[] = {
for (const auto &Input : Inputs) {
     for (StringMap<FunctionSamples>::iterator I = Profiles.begin(),
                                               E = Profiles.end();
          I != E; ++I) {
       StringRef FName = I->first();
       FunctionSamples &Samples = I->second;
       sampleprof_error Result = ProfileMap[FName].merge(Samples, Input.Weight);
       if (Result != sampleprof_error::success) {
         std::error_code EC = make_error_code(Result);
-        handleMergeWriterError(EC, Input.Filename, FName);
+        handleMergeWriterError(errorCodeToError(EC), Input.Filename, FName);
       }
     }
   }
   Writer->write(ProfileMap);
 }
 
 static WeightedFile parseWeightedFile(const StringRef &WeightedFilename) {
   StringRef WeightStr, FileName;
static int showInstrProfile(std::string Filename, bool ShowCounts,
                             bool ShowAllFunctions, std::string ShowFunction,
                             bool TextFormat, raw_fd_ostream &OS) {
   auto ReaderOrErr = InstrProfReader::create(Filename);
   std::vector<uint32_t> Cutoffs(DetailedSummaryCutoffs);
   if (ShowDetailedSummary && DetailedSummaryCutoffs.empty()) {
     Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
   }
   InstrProfSummary PS(Cutoffs);
-  if (std::error_code EC = ReaderOrErr.getError())
-    exitWithErrorCode(EC, Filename);
+  if (Error E = ReaderOrErr.takeError())
+    exitWithError(std::move(E), Filename);
 
   auto Reader = std::move(ReaderOrErr.get());
   bool IsIRInstr = Reader->isIRLevelProfile();
   size_t ShownFunctions = 0;
   for (const auto &Func : *Reader) {
     bool Show =
         ShowAllFunctions || (!ShowFunction.empty() &&
                              Func.Name.find(ShowFunction) != Func.Name.npos);
if (Show) {
                << " ]\n";
           }
         }
       }
     }
   }
 
   if (Reader->hasError())
-    exitWithErrorCode(Reader->getError(), Filename);
+    exitWithError(Reader->getError(), Filename);
 
   if (ShowCounts && TextFormat)
     return 0;
 
   if (ShowAllFunctions || !ShowFunction.empty())
     OS << "Functions shown: " << ShownFunctions << "\n";
   OS << "Total functions: " << PS.getNumFunctions() << "\n";
   OS << "Maximum function count: " << PS.getMaxFunctionCount() << "\n";

unittests/ProfileData/CoverageMappingTest.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 #include <ostream>
 
 using namespace llvm;
 using namespace coverage;
 
-static ::testing::AssertionResult NoError(std::error_code EC) {
-  if (!EC)
+static ::testing::AssertionResult NoError(Error E) {
+  if (!E)
     return ::testing::AssertionSuccess();
-  return ::testing::AssertionFailure() << "error " << EC.value()
-                                       << ": " << EC.message();
+  return ::testing::AssertionFailure() << "error: " << toString(std::move(E))
+                                       << "\n";
 }
 
 namespace llvm {
 namespace coverage {
 void PrintTo(const Counter &C, ::std::ostream *os) {
   if (C.isZero())
     *os << "Zero";
   else if (C.isExpression())

 };
 
 struct CoverageMappingReaderMock : CoverageMappingReader {
   ArrayRef<OutputFunctionCoverageData> Functions;
 
   CoverageMappingReaderMock(ArrayRef<OutputFunctionCoverageData> Functions)
       : Functions(Functions) {}
 
-  std::error_code readNextRecord(CoverageMappingRecord &Record) override {
+  Error readNextRecord(CoverageMappingRecord &Record) override {
     if (Functions.empty())
-      return instrprof_error::eof;
+      return make_error<InstrProfError>(instrprof_error::eof);
 
     Functions.front().fillCoverageMappingRecord(Record);
     Functions = Functions.slice(1);
 
-    return instrprof_error::success;
+    return Error::success();
   }
 };
 
 struct InputFunctionCoverageData {
   // Maps the global file index from CoverageMappingTest.Files
   // to the index of that file within this function. We can't just use
   // global file indexes here because local indexes have to be dense.
   // This map is used during serialization to create the virtual file mapping
for (unsigned I = 0; I < InputFunctions.size(); ++I) {
       if (!EmitFilenames)
         OutputFunctions[I].Filenames.clear();
     }
   }
 
   void readProfCounts() {
     auto Profile = ProfileWriter.writeBuffer();
     auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
-    ASSERT_TRUE(NoError(ReaderOrErr.getError()));
+    ASSERT_TRUE(NoError(ReaderOrErr.takeError()));
     ProfileReader = std::move(ReaderOrErr.get());
   }
 
   void loadCoverageMapping(bool EmitFilenames = true) {
     readProfCounts();
     writeAndReadCoverageRegions(EmitFilenames);
 
     CoverageMappingReaderMock CovReader(OutputFunctions);
     auto CoverageOrErr = CoverageMapping::load(CovReader, *ProfileReader);
-    ASSERT_TRUE(NoError(CoverageOrErr.getError()));
+    ASSERT_TRUE(NoError(CoverageOrErr.takeError()));
     LoadedCoverage = std::move(CoverageOrErr.get());
   }
 };
 
 struct MaybeSparseCoverageMappingTest
     : public CoverageMappingTest,
       public ::testing::WithParamInterface<bool> {
   void SetUp() {

unittests/ProfileData/InstrProfTest.cpp

 #include "llvm/ProfileData/InstrProfReader.h"
 #include "llvm/ProfileData/InstrProfWriter.h"
 #include "llvm/Support/Compression.h"
 #include "gtest/gtest.h"
 #include <cstdarg>
 
 using namespace llvm;
 
-static ::testing::AssertionResult NoError(std::error_code EC) {
-  if (!EC)
+static ::testing::AssertionResult NoError(Error E) {
+  if (!E)
     return ::testing::AssertionSuccess();
-  return ::testing::AssertionFailure() << "error " << EC.value()
-                                       << ": " << EC.message();
+  return ::testing::AssertionFailure() << "error: " << toString(std::move(E))
+                                       << "\n";
 }
 
-static ::testing::AssertionResult ErrorEquals(std::error_code Expected,
-                                              std::error_code Found) {
+static ::testing::AssertionResult ErrorEquals(instrprof_error Expected,
+                                              Error E) {
+  instrprof_error Found;
+  std::string FoundMsg;
+  handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
+    Found = IPE.get();
+    FoundMsg = IPE.message();
+  });
   if (Expected == Found)
     return ::testing::AssertionSuccess();
-  return ::testing::AssertionFailure() << "error " << Found.value()
-                                       << ": " << Found.message();
+  return ::testing::AssertionFailure() << "error: " << FoundMsg << "\n";
 }
 
 namespace {
 
 struct InstrProfTest : ::testing::Test {
   InstrProfWriter Writer;
   std::unique_ptr<IndexedInstrProfReader> Reader;
 
   void SetUp() { Writer.setOutputSparse(false); }
 
   void readProfile(std::unique_ptr<MemoryBuffer> Profile) {
     auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
-    ASSERT_TRUE(NoError(ReaderOrErr.getError()));
+    ASSERT_TRUE(NoError(ReaderOrErr.takeError()));
     Reader = std::move(ReaderOrErr.get());
   }
 };
 
 struct SparseInstrProfTest : public InstrProfTest {
   void SetUp() { Writer.setOutputSparse(true); }
 };
 

 TEST_P(MaybeSparseInstrProfTest, get_instr_prof_record) {
   InstrProfRecord Record1("foo", 0x1234, {1, 2});
   InstrProfRecord Record2("foo", 0x1235, {3, 4});
   NoError(Writer.addRecord(std::move(Record1)));
   NoError(Writer.addRecord(std::move(Record2)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("foo", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("foo", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(2U, R->Counts.size());
   ASSERT_EQ(1U, R->Counts[0]);
   ASSERT_EQ(2U, R->Counts[1]);
 
   R = Reader->getInstrProfRecord("foo", 0x1235);
-  ASSERT_TRUE(NoError(R.getError()));
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(2U, R->Counts.size());
   ASSERT_EQ(3U, R->Counts[0]);
   ASSERT_EQ(4U, R->Counts[1]);
 
   R = Reader->getInstrProfRecord("foo", 0x5678);
-  ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.getError()));
+  ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.takeError()));
 
   R = Reader->getInstrProfRecord("bar", 0x1234);
-  ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, R.getError()));
+  ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, R.takeError()));
 }
 
 TEST_P(MaybeSparseInstrProfTest, get_function_counts) {
   InstrProfRecord Record1("foo", 0x1234, {1, 2});
   InstrProfRecord Record2("foo", 0x1235, {3, 4});
   NoError(Writer.addRecord(std::move(Record1)));
   NoError(Writer.addRecord(std::move(Record2)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   std::vector<uint64_t> Counts;
   ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1234, Counts)));
   ASSERT_EQ(2U, Counts.size());
   ASSERT_EQ(1U, Counts[0]);
   ASSERT_EQ(2U, Counts[1]);
 
   ASSERT_TRUE(NoError(Reader->getFunctionCounts("foo", 0x1235, Counts)));
   ASSERT_EQ(2U, Counts.size());
   ASSERT_EQ(3U, Counts[0]);
   ASSERT_EQ(4U, Counts[1]);
 
-  std::error_code EC;
-  EC = Reader->getFunctionCounts("foo", 0x5678, Counts);
-  ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, EC));
+  Error E1 = Reader->getFunctionCounts("foo", 0x5678, Counts);
+  ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, std::move(E1)));
 
-  EC = Reader->getFunctionCounts("bar", 0x1234, Counts);
-  ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, EC));
+  Error E2 = Reader->getFunctionCounts("bar", 0x1234, Counts);
+  ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, std::move(E2)));
 }
 
 // Profile data is copied from general.proftext
 TEST_F(InstrProfTest, get_profile_summary) {
   InstrProfRecord Record1("func1", 0x1234, {97531});
   InstrProfRecord Record2("func2", 0x1234, {0, 0});
   InstrProfRecord Record3("func3", 0x1234,
                           {2305843009213693952, 1152921504606846976,
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write) {
 
   NoError(Writer.addRecord(std::move(Record1)));
   NoError(Writer.addRecord(std::move(Record2)));
   NoError(Writer.addRecord(std::move(Record3)));
   NoError(Writer.addRecord(std::move(Record4)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
 
   uint64_t TotalC;
   std::unique_ptr<InstrProfValueData[]> VD =
TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   InstrProfRecord Record("caller", 0x1234, {1, 2});
   Record.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD0[] = {{1000, 1}, {2000, 2}, {3000, 3}, {5000, 5},
                               {4000, 4}, {6000, 6}};
   Record.addValueData(IPVK_IndirectCallTarget, 0, VD0, 6, nullptr);
   NoError(Writer.addRecord(std::move(Record)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                         /*isVarArg=*/false);
   Function *F =
       Function::Create(FTy, Function::ExternalLinkage, "caller", M.get());
   BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_with_weight) {
 
   NoError(Writer.addRecord(std::move(Record1), 10));
   NoError(Writer.addRecord(std::move(Record2)));
   NoError(Writer.addRecord(std::move(Record3)));
   NoError(Writer.addRecord(std::move(Record4)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
 
   uint64_t TotalC;
   std::unique_ptr<InstrProfValueData[]> VD =
TEST_P(MaybeSparseInstrProfTest, get_icall_data_read_write_big_endian) {
   Writer.setValueProfDataEndianness(support::big);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   // Set big endian input.
   Reader->setValueProfDataEndianness(support::big);
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(2U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
 
   std::unique_ptr<InstrProfValueData[]> VD =
       R->getValueForSite(IPVK_IndirectCallTarget, 0);
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1) {
   NoError(Writer.addRecord(std::move(Record2)));
   NoError(Writer.addRecord(std::move(Record3)));
   NoError(Writer.addRecord(std::move(Record4)));
   NoError(Writer.addRecord(std::move(Record5)));
   NoError(Writer.addRecord(std::move(Record6)));
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   ASSERT_EQ(5U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
   ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 2));
   ASSERT_EQ(1U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 3));
   ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 4));
 
   std::unique_ptr<InstrProfValueData[]> VD =

 
 TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge1_saturation) {
   static const char bar[] = "bar";
 
   const uint64_t Max = std::numeric_limits<uint64_t>::max();
 
   InstrProfRecord Record1("foo", 0x1234, {1});
   auto Result1 = Writer.addRecord(std::move(Record1));
-  ASSERT_EQ(Result1, instrprof_error::success);
+  ASSERT_EQ(InstrProfError::take(std::move(Result1)),
+            instrprof_error::success);
 
   // Verify counter overflow.
   InstrProfRecord Record2("foo", 0x1234, {Max});
   auto Result2 = Writer.addRecord(std::move(Record2));
-  ASSERT_EQ(Result2, instrprof_error::counter_overflow);
+  ASSERT_EQ(InstrProfError::take(std::move(Result2)),
+            instrprof_error::counter_overflow);
 
   InstrProfRecord Record3(bar, 0x9012, {8});
   auto Result3 = Writer.addRecord(std::move(Record3));
-  ASSERT_EQ(Result3, instrprof_error::success);
+  ASSERT_EQ(InstrProfError::take(std::move(Result3)),
+            instrprof_error::success);
 
   InstrProfRecord Record4("baz", 0x5678, {3, 4});
   Record4.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD4[] = {{uint64_t(bar), 1}};
   Record4.addValueData(IPVK_IndirectCallTarget, 0, VD4, 1, nullptr);
   auto Result4 = Writer.addRecord(std::move(Record4));
-  ASSERT_EQ(Result4, instrprof_error::success);
+  ASSERT_EQ(InstrProfError::take(std::move(Result4)),
+            instrprof_error::success);
 
   // Verify value data counter overflow.
   InstrProfRecord Record5("baz", 0x5678, {5, 6});
   Record5.reserveSites(IPVK_IndirectCallTarget, 1);
   InstrProfValueData VD5[] = {{uint64_t(bar), Max}};
   Record5.addValueData(IPVK_IndirectCallTarget, 0, VD5, 1, nullptr);
   auto Result5 = Writer.addRecord(std::move(Record5));
-  ASSERT_EQ(Result5, instrprof_error::counter_overflow);
+  ASSERT_EQ(InstrProfError::take(std::move(Result5)),
+            instrprof_error::counter_overflow);
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
   // Verify saturation of counts.
-  ErrorOr<InstrProfRecord> ReadRecord1 =
+  Expected<InstrProfRecord> ReadRecord1 =
       Reader->getInstrProfRecord("foo", 0x1234);
-  ASSERT_TRUE(NoError(ReadRecord1.getError()));
+  ASSERT_TRUE(NoError(ReadRecord1.takeError()));
   ASSERT_EQ(Max, ReadRecord1->Counts[0]);
 
-  ErrorOr<InstrProfRecord> ReadRecord2 =
+  Expected<InstrProfRecord> ReadRecord2 =
       Reader->getInstrProfRecord("baz", 0x5678);
+  ASSERT_TRUE(bool(ReadRecord2));
   ASSERT_EQ(1U, ReadRecord2->getNumValueSites(IPVK_IndirectCallTarget));
   std::unique_ptr<InstrProfValueData[]> VD =
       ReadRecord2->getValueForSite(IPVK_IndirectCallTarget, 0);
   ASSERT_EQ(StringRef("bar"), StringRef((const char *)VD[0].Value, 3));
   ASSERT_EQ(Max, VD[0].Count);
 }
 
 // This test tests that when there are too many values
TEST_P(MaybeSparseInstrProfTest, get_icall_data_merge_site_trunc) {
 
   NoError(Writer.addRecord(std::move(Record11)));
   // Merge profile data.
   NoError(Writer.addRecord(std::move(Record12)));
 
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
 
-  ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
-  ASSERT_TRUE(NoError(R.getError()));
+  Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
+  ASSERT_TRUE(NoError(R.takeError()));
   std::unique_ptr<InstrProfValueData[]> VD(
       R->getValueForSite(IPVK_IndirectCallTarget, 0));
   ASSERT_EQ(2U, R->getNumValueSites(IPVK_IndirectCallTarget));
   ASSERT_EQ(255U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
   for (unsigned I = 0; I < 255; I++) {
     ASSERT_EQ(VD[I].Value, 509 - I);
     ASSERT_EQ(VD[I].Count, 1509 - I);
   }