[llvm] r269491 - Retry "[ProfileData] (llvm) Use Error in InstrProf and Coverage, NFC"
Chandler Carruth via llvm-commits
llvm-commits at lists.llvm.org
Fri May 13 22:32:47 PDT 2016
And revert is landed in r269547. Sorry for any trouble!
On Fri, May 13, 2016 at 11:32 PM Chandler Carruth <chandlerc at google.com>
wrote:
> (Note that Craig tried to fix this without a revert but wasn't successful,
> I think at this point revert is the best option...)
>
> On Fri, May 13, 2016 at 11:22 PM Chandler Carruth <chandlerc at google.com>
> wrote:
>
>> It's also breaking -Werror build bots:
>> http://lab.llvm.org:8011/builders/sanitizer-ppc64le-linux/builds/1079
>>
>> I'm reverting this for now, we've lost hours and hours of build bot
>> coverage already.
>>
>> On Fri, May 13, 2016 at 7:13 PM Craig Topper via llvm-commits <
>> llvm-commits at lists.llvm.org> wrote:
>>
>>> I think this is causing some warnings on my build like this
>>>
>>> *llvm/include/llvm/Support/Error.h:301:52: **warning: **instantiation
>>> of variable 'llvm::ProfErrorInfoBase<llvm::instrprof_error>::ID' required
>>> here, but no definition is available [-Wundefined-var-template]*
>>>
>>> static const void *classID() { return &ThisErrT::ID; }
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:61:28: **note: *in instantiation of
>>> member function
>>> 'llvm::ErrorInfo<llvm::ProfErrorInfoBase<llvm::instrprof_error>,
>>> llvm::ErrorInfoBase>::classID' requested here
>>>
>>> return isA(ErrorInfoT::classID());
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:399:23: **note: *in instantiation of
>>> function template specialization
>>> 'llvm::ErrorInfoBase::isA<llvm::InstrProfError>' requested here
>>>
>>> return E.template isA<ErrT>();
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:482:37: **note: *in instantiation of
>>> member function 'llvm::ErrorHandlerTraits<void (&)(llvm::InstrProfError
>>> &)>::appliesTo' requested here
>>>
>>> if (ErrorHandlerTraits<HandlerT>::appliesTo(*Payload))
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:508:11: **note: *in instantiation of
>>> function template specialization 'llvm::handleErrorImpl<(lambda at
>>> llvm/include/llvm/ProfileData/InstrProf.h:294:35)>' requested here
>>>
>>> handleErrorImpl(std::move(P), std::forward<HandlerTs>(Hs)...));
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:520:12: **note: *in instantiation of
>>> function template specialization 'llvm::handleErrors<(lambda at
>>> llvm/include/llvm/ProfileData/InstrProf.h:294:35)>' requested here
>>>
>>> auto F = handleErrors(std::move(E),
>>> std::forward<HandlerTs>(Handlers)...);
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/ProfileData/InstrProf.h:294:5: **note: *in
>>> instantiation of function template specialization
>>> 'llvm::handleAllErrors<(lambda at
>>> llvm/include/llvm/ProfileData/InstrProf.h:294:35)>' requested here
>>>
>>> handleAllErrors(std::move(E), [&Err](const InstrProfError &IPE) {
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/ProfileData/ProfileCommon.h:57:15: **note: *forward
>>> declaration of template entity is here
>>>
>>> static char ID;
>>>
>>> * ^*
>>>
>>> *llvm/include/llvm/Support/Error.h:301:52: **note: *add an explicit
>>> instantiation declaration to suppress this warning if
>>> 'llvm::ProfErrorInfoBase<llvm::instrprof_error>::ID' is explicitly
>>> instantiated in another translation unit
>>>
>>> static const void *classID() { return &ThisErrT::ID; }
>>>
>>> * ^*
>>>
>>> 1 warning generated.
>>>
>>> On Fri, May 13, 2016 at 2:50 PM, Vedant Kumar via llvm-commits <
>>> llvm-commits at lists.llvm.org> wrote:
>>>
>>>> Author: vedantk
>>>> Date: Fri May 13 16:50:56 2016
>>>> New Revision: 269491
>>>>
>>>> URL: http://llvm.org/viewvc/llvm-project?rev=269491&view=rev
>>>> Log:
>>>> Retry "[ProfileData] (llvm) Use Error in InstrProf and Coverage, NFC"
>>>>
>>>> Transition InstrProf and Coverage over to the stricter Error/Expected
>>>> interface.
>>>>
>>>> Changes since the initial commit:
>>>> - Fix error message printing in llvm-profdata.
>>>> - Check errors in loadTestingFormat() + annotateAllFunctions().
>>>> - Defer error handling in InstrProfIterator to InstrProfReader.
>>>>
>>>> Differential Revision: http://reviews.llvm.org/D19901
>>>>
>>>> Modified:
>>>> llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h
>>>> llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
>>>> llvm/trunk/include/llvm/ProfileData/InstrProf.h
>>>> llvm/trunk/include/llvm/ProfileData/InstrProfData.inc
>>>> llvm/trunk/include/llvm/ProfileData/InstrProfReader.h
>>>> llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h
>>>> llvm/trunk/include/llvm/ProfileData/ProfileCommon.h
>>>> llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp
>>>> llvm/trunk/lib/ProfileData/Coverage/CoverageMappingReader.cpp
>>>> llvm/trunk/lib/ProfileData/InstrProf.cpp
>>>> llvm/trunk/lib/ProfileData/InstrProfReader.cpp
>>>> llvm/trunk/lib/ProfileData/InstrProfWriter.cpp
>>>> llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp
>>>> llvm/trunk/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
>>>> llvm/trunk/tools/llvm-cov/CodeCoverage.cpp
>>>> llvm/trunk/tools/llvm-profdata/llvm-profdata.cpp
>>>> llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp
>>>> llvm/trunk/unittests/ProfileData/InstrProfTest.cpp
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h
>>>> (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMapping.h Fri
>>>> May 13 16:50:56 2016
>>>> @@ -23,13 +23,13 @@
>>>> #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,
>>>> eof,
>>>> @@ -38,13 +38,16 @@ enum class coveragemap_error {
>>>> truncated,
>>>> malformed
>>>> };
>>>> -} // end of coverage namespace.
>>>> -}
>>>>
>>>> -namespace std {
>>>> -template <>
>>>> -struct is_error_code_enum<llvm::coverage::coveragemap_error> :
>>>> std::true_type {
>>>> +class CoverageMapError : public ProfErrorInfoBase<coveragemap_error> {
>>>> +public:
>>>> + CoverageMapError(coveragemap_error Err)
>>>> + : ProfErrorInfoBase<coveragemap_error>(Err) {}
>>>> +
>>>> + std::string message() const override;
>>>> };
>>>> +
>>>> +} // end of coverage namespace.
>>>> }
>>>>
>>>> namespace llvm {
>>>> @@ -265,7 +268,7 @@ public:
>>>>
>>>> /// \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.
>>>> @@ -415,12 +418,12 @@ class CoverageMapping {
>>>>
>>>> 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());
>>>>
>>>> @@ -501,14 +504,13 @@ template <class IntPtrT> struct CovMapFu
>>>> }
>>>> // 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();
>>>> }
>>>> };
>>>>
>>>> @@ -530,11 +532,10 @@ struct CovMapFunctionRecord {
>>>> }
>>>> // 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();
>>>> }
>>>> };
>>>>
>>>>
>>>> Modified:
>>>> llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> ---
>>>> llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h
>>>> (original)
>>>> +++
>>>> llvm/trunk/include/llvm/ProfileData/Coverage/CoverageMappingReader.h Fri
>>>> May 13 16:50:56 2016
>>>> @@ -69,7 +69,7 @@ public:
>>>>
>>>> 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() {}
>>>> @@ -82,10 +82,10 @@ protected:
>>>>
>>>> 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.
>>>> @@ -100,7 +100,7 @@ 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.
>>>> @@ -125,12 +125,12 @@ public:
>>>> 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);
>>>> };
>>>> @@ -170,11 +170,11 @@ private:
>>>> 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
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/InstrProf.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/InstrProf.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/InstrProf.h (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/InstrProf.h Fri May 13 16:50:56
>>>> 2016
>>>> @@ -25,7 +25,6 @@
>>>> #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/MathExtras.h"
>>>> #include <cstdint>
>>>> @@ -204,20 +203,17 @@ StringRef getFuncNameWithoutPrefix(Strin
>>>> /// 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,
>>>> - bool doCompression, std::string &Result);
>>>> +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,
>>>> - std::string &Result, bool doCompression =
>>>> true);
>>>> +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,
>>>> @@ -284,6 +280,25 @@ inline std::error_code make_error_code(i
>>>> return std::error_code(static_cast<int>(E), instrprof_category());
>>>> }
>>>>
>>>> +class InstrProfError : public ProfErrorInfoBase<instrprof_error> {
>>>> +public:
>>>> + InstrProfError(instrprof_error Err)
>>>> + : ProfErrorInfoBase<instrprof_error>(Err) {}
>>>> +
>>>> + 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.
>>>> @@ -309,6 +324,11 @@ public:
>>>> 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);
>>>>
>>>> @@ -326,8 +346,15 @@ public:
>>>> 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 and reset FirstError to a
>>>> success
>>>> + /// value.
>>>> + Error takeError() {
>>>> + if (FirstError == instrprof_error::success)
>>>> + return Error::success();
>>>> + auto E = make_error<InstrProfError>(FirstError);
>>>> + FirstError = instrprof_error::success;
>>>> + return E;
>>>> + }
>>>> };
>>>>
>>>> namespace object {
>>>> @@ -372,14 +399,14 @@ public:
>>>> /// 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
>>>> @@ -424,13 +451,13 @@ public:
>>>> 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);
>>>> }
>>>>
>>>> @@ -572,7 +599,7 @@ struct InstrProfRecord {
>>>> }
>>>>
>>>> /// 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;
>>>> @@ -890,9 +917,4 @@ struct Header {
>>>>
>>>> } // end namespace llvm
>>>>
>>>> -namespace std {
>>>> -template <>
>>>> -struct is_error_code_enum<llvm::instrprof_error> : std::true_type {};
>>>> -}
>>>> -
>>>> #endif // LLVM_PROFILEDATA_INSTRPROF_H
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/InstrProfData.inc
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/InstrProfData.inc?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/InstrProfData.inc (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/InstrProfData.inc Fri May 13
>>>> 16:50:56 2016
>>>> @@ -295,16 +295,15 @@ typedef struct ValueProfData {
>>>> 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);
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/InstrProfReader.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/InstrProfReader.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/InstrProfReader.h (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/InstrProfReader.h Fri May 13
>>>> 16:50:56 2016
>>>> @@ -19,7 +19,6 @@
>>>> #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"
>>>> @@ -51,16 +50,16 @@ public:
>>>> /// 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(); }
>>>> @@ -80,28 +79,35 @@ public:
>>>>
>>>> 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() {
>>>> + if (hasError())
>>>> + return make_error<InstrProfError>(LastError);
>>>> + return Error::success();
>>>> + }
>>>>
>>>> /// 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);
>>>> };
>>>>
>>>> @@ -123,7 +129,7 @@ private:
>>>>
>>>> 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_)
>>>> @@ -136,9 +142,9 @@ public:
>>>> 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());
>>>> @@ -185,8 +191,8 @@ public:
>>>> : 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;
>>>> }
>>>> @@ -197,9 +203,9 @@ public:
>>>> }
>>>>
>>>> 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;
>>>> }
>>>> @@ -216,10 +222,10 @@ private:
>>>> 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++;
>>>> @@ -300,9 +306,9 @@ public:
>>>> 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;
>>>> @@ -330,9 +336,9 @@ public:
>>>> 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,
>>>> + ArrayRef<InstrProfRecord> &Data) override;
>>>> void advanceToNextKey() override { RecordIterator++; }
>>>> bool atEnd() const override {
>>>> return RecordIterator == HashTable->data_end();
>>>> @@ -379,27 +385,27 @@ public:
>>>> 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,
>>>> - uint64_t FuncHash);
>>>> + 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,
>>>> + std::vector<uint64_t> &Counts);
>>>>
>>>> /// 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.
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/InstrProfWriter.h Fri May 13
>>>> 16:50:56 2016
>>>> @@ -46,7 +46,7 @@ public:
>>>> /// 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
>>>> @@ -58,13 +58,15 @@ public:
>>>> 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.
>>>>
>>>> Modified: llvm/trunk/include/llvm/ProfileData/ProfileCommon.h
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/ProfileData/ProfileCommon.h?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/include/llvm/ProfileData/ProfileCommon.h (original)
>>>> +++ llvm/trunk/include/llvm/ProfileData/ProfileCommon.h Fri May 13
>>>> 16:50:56 2016
>>>> @@ -21,6 +21,7 @@
>>>> #include <vector>
>>>>
>>>> #include "llvm/Support/Casting.h"
>>>> +#include "llvm/Support/Error.h"
>>>>
>>>> namespace llvm {
>>>> class Function;
>>>> @@ -36,6 +37,29 @@ class Metadata;
>>>> class MDTuple;
>>>> class MDNode;
>>>>
>>>> +template <typename ErrT>
>>>> +class ProfErrorInfoBase : public ErrorInfo<ProfErrorInfoBase<ErrT>> {
>>>> +public:
>>>> + ProfErrorInfoBase(ErrT Err) : Err(Err) {
>>>> + assert(Err != ErrT::success && "Not an error");
>>>> + }
>>>> +
>>>> + virtual std::string message() const override = 0;
>>>> +
>>>> + void log(raw_ostream &OS) const override { OS << message(); }
>>>> +
>>>> + 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"; }
>>>>
>>>>
>>>> Modified: llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp (original)
>>>> +++ llvm/trunk/lib/ProfileData/Coverage/CoverageMapping.cpp Fri May 13
>>>> 16:50:56 2016
>>>> @@ -143,28 +143,30 @@ void CounterMappingContext::dump(const C
>>>> }
>>>> 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;
>>>> @@ -181,7 +183,7 @@ void FunctionRecordIterator::skipOtherFi
>>>> *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());
>>>> @@ -191,13 +193,14 @@ CoverageMapping::load(CoverageMappingRea
>>>> 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);
>>>> @@ -212,9 +215,11 @@ CoverageMapping::load(CoverageMappingRea
>>>> 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()) {
>>>> @@ -228,20 +233,20 @@ CoverageMapping::load(CoverageMappingRea
>>>> 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);
>>>> }
>>>> @@ -533,27 +538,34 @@ CoverageMapping::getCoverageForExpansion
>>>> }
>>>>
>>>> namespace {
>>>> +std::string getCoverageMapErrString(coveragemap_error Err) {
>>>> + switch (Err) {
>>>> + case coveragemap_error::success:
>>>> + return "Success";
>>>> + case coveragemap_error::eof:
>>>> + return "End of File";
>>>> + case coveragemap_error::no_data_found:
>>>> + return "No coverage data found";
>>>> + case coveragemap_error::unsupported_version:
>>>> + return "Unsupported coverage format version";
>>>> + case coveragemap_error::truncated:
>>>> + return "Truncated coverage data";
>>>> + case coveragemap_error::malformed:
>>>> + return "Malformed coverage data";
>>>> + }
>>>> + llvm_unreachable("A value of coveragemap_error has no message.");
>>>> +}
>>>> +
>>>> class CoverageMappingErrorCategoryType : public std::error_category {
>>>> const char *name() const LLVM_NOEXCEPT override { return
>>>> "llvm.coveragemap"; }
>>>> std::string message(int IE) const override {
>>>> - 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.");
>>>> + return getCoverageMapErrString(static_cast<coveragemap_error>(IE));
>>>> }
>>>> };
>>>> +} // end anonymous namespace
>>>> +
>>>> +std::string CoverageMapError::message() const {
>>>> + return getCoverageMapErrString(Err);
>>>> }
>>>>
>>>> static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory;
>>>> @@ -561,3 +573,5 @@ static ManagedStatic<CoverageMappingErro
>>>> const std::error_category &llvm::coverage::coveragemap_category() {
>>>> return *ErrorCategory;
>>>> }
>>>> +
>>>> +template <> char ProfErrorInfoBase<coveragemap_error>::ID = 0;
>>>>
>>>> Modified: llvm/trunk/lib/ProfileData/Coverage/CoverageMappingReader.cpp
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ProfileData/Coverage/CoverageMappingReader.cpp?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/ProfileData/Coverage/CoverageMappingReader.cpp
>>>> (original)
>>>> +++ llvm/trunk/lib/ProfileData/Coverage/CoverageMappingReader.cpp Fri
>>>> May 13 16:50:56 2016
>>>> @@ -31,49 +31,54 @@ using namespace object;
>>>> void CoverageMappingIterator::increment() {
>>>> // 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) {
>>>> + if (CME.get() == coveragemap_error::eof)
>>>> + *this = CoverageMappingIterator();
>>>> + else
>>>> + llvm_unreachable("Unexpected error in coverage mapping
>>>> iterator");
>>>> + });
>>>> + }
>>>> }
>>>>
>>>> -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;
>>>> @@ -83,19 +88,18 @@ std::error_code RawCoverageFilenamesRead
>>>> 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;
>>>> }
>>>> @@ -105,25 +109,25 @@ std::error_code RawCoverageMappingReader
>>>> 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
>>>> @@ -132,7 +136,7 @@ static const unsigned EncodingExpansionR
>>>> /// \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;
>>>> @@ -160,7 +164,7 @@ std::error_code RawCoverageMappingReader
>>>> ExpandedFileID = EncodedCounterAndRegion >>
>>>>
>>>> Counter::EncodingCounterTagAndExpansionRegionTagBits;
>>>> if (ExpandedFileID >= NumFileIDs)
>>>> - return coveragemap_error::malformed;
>>>> + return
>>>> make_error<CoverageMapError>(coveragemap_error::malformed);
>>>> } else {
>>>> switch (EncodedCounterAndRegion >>
>>>> Counter::EncodingCounterTagAndExpansionRegionTagBits) {
>>>> @@ -171,7 +175,7 @@ std::error_code RawCoverageMappingReader
>>>> Kind = CounterMappingRegion::SkippedRegion;
>>>> break;
>>>> default:
>>>> - return coveragemap_error::malformed;
>>>> + return
>>>> make_error<CoverageMapError>(coveragemap_error::malformed);
>>>> }
>>>> }
>>>> }
>>>> @@ -184,7 +188,7 @@ std::error_code RawCoverageMappingReader
>>>> 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()))
>>>> @@ -218,10 +222,10 @@ std::error_code RawCoverageMappingReader
>>>> 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;
>>>> @@ -287,14 +291,14 @@ std::error_code RawCoverageMappingReader
>>>> }
>>>> }
>>>>
>>>> - 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) {
>>>> @@ -312,11 +316,10 @@ struct CovMapFuncRecordReader {
>>>> // a module. \p Buf is a reference to the buffer pointer pointing
>>>> // to the \c CovHeader of coverage mapping data associated with
>>>> // the module.
>>>> - virtual 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);
>>>> @@ -344,11 +347,10 @@ public:
>>>> : 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>();
>>>> @@ -363,7 +365,7 @@ public:
>>>>
>>>> // 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())
>>>> @@ -376,7 +378,7 @@ public:
>>>> 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);
>>>> @@ -389,7 +391,7 @@ public:
>>>>
>>>> // 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;
>>>>
>>>> @@ -403,21 +405,20 @@ public:
>>>> }
>>>>
>>>> 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) {
>>>> @@ -428,8 +429,8 @@ ErrorOr<std::unique_ptr<CovMapFuncRecord
>>>> 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);
>>>> }
>>>> @@ -437,7 +438,7 @@ ErrorOr<std::unique_ptr<CovMapFuncRecord
>>>> }
>>>>
>>>> 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) {
>>>> @@ -447,89 +448,90 @@ static std::error_code readCoverageMappi
>>>> 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,
>>>> + StringRef &CoverageMapping,
>>>> + uint8_t &BytesInAddress,
>>>> + support::endianness &Endian) {
>>>> BytesInAddress = 8;
>>>> Endian = support::endianness::little;
>>>>
>>>> Data = Data.substr(StringRef(TestingFormatMagic).size());
>>>> if (Data.size() < 1)
>>>> - return 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;
>>>> - ProfileNames.create(Data.substr(0, ProfileNamesSize), Address);
>>>> + return make_error<CoverageMapError>(coveragemap_error::malformed);
>>>> + if (Error E = ProfileNames.create(Data.substr(0, ProfileNamesSize),
>>>> Address))
>>>> + return E;
>>>> 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,
>>>> - support::endianness &Endian, StringRef Arch) {
>>>> +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();
>>>> @@ -538,23 +540,23 @@ loadBinaryFormat(MemoryBufferRef ObjectB
>>>>
>>>> // 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());
>>>> @@ -562,44 +564,44 @@ BinaryCoverageReader::create(std::unique
>>>> 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,
>>>> + Coverage, BytesInAddress, Endian);
>>>> else
>>>> - EC = loadBinaryFormat(ObjectBuffer->getMemBufferRef(),
>>>> Reader->ProfileNames,
>>>> - Coverage, BytesInAddress, Endian, Arch);
>>>> - if (EC)
>>>> - return EC;
>>>> + E = loadBinaryFormat(ObjectBuffer->getMemBufferRef(),
>>>> Reader->ProfileNames,
>>>> + Coverage, BytesInAddress, Endian, Arch);
>>>> + 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();
>>>> @@ -619,5 +621,5 @@ BinaryCoverageReader::readNextRecord(Cov
>>>> Record.MappingRegions = MappingRegions;
>>>>
>>>> ++CurrentRecord;
>>>> - return std::error_code();
>>>> + return Error::success();
>>>> }
>>>>
>>>> Modified: llvm/trunk/lib/ProfileData/InstrProf.cpp
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ProfileData/InstrProf.cpp?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/ProfileData/InstrProf.cpp (original)
>>>> +++ llvm/trunk/lib/ProfileData/InstrProf.cpp Fri May 13 16:50:56 2016
>>>> @@ -27,47 +27,50 @@
>>>> using namespace llvm;
>>>>
>>>> namespace {
>>>> +std::string getInstrProfErrString(instrprof_error Err) {
>>>> + switch (Err) {
>>>> + 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.");
>>>> +}
>>>> +
>>>> 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.");
>>>> + return getInstrProfErrString(static_cast<instrprof_error>(IE));
>>>> }
>>>> };
>>>> } // end anonymous namespace
>>>> @@ -105,6 +108,12 @@ void SoftInstrProfErrors::addError(instr
>>>> }
>>>> }
>>>>
>>>> +std::string InstrProfError::message() const {
>>>> + return getInstrProfErrString(Err);
>>>> +}
>>>> +
>>>> +template <> char ProfErrorInfoBase<instrprof_error>::ID = 0;
>>>> +
>>>> std::string getPGOFuncName(StringRef RawFuncName,
>>>> GlobalValue::LinkageTypes Linkage,
>>>> StringRef FileName,
>>>> @@ -214,9 +223,8 @@ void InstrProfSymtab::create(Module &M,
>>>> finalizeSymtab();
>>>> }
>>>>
>>>> -std::error_code
>>>> -collectPGOFuncNameStrings(const std::vector<std::string> &NameStrs,
>>>> - bool doCompression, std::string &Result) {
>>>> +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;
>>>> @@ -238,11 +246,12 @@ collectPGOFuncNameStrings(const std::vec
>>>> 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 =
>>>> @@ -250,7 +259,7 @@ collectPGOFuncNameStrings(const std::vec
>>>> 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(),
>>>> @@ -264,9 +273,8 @@ StringRef getPGOFuncNameVarInitializer(G
>>>> return NameStr;
>>>> }
>>>>
>>>> -std::error_code
>>>> -collectPGOFuncNameStrings(const std::vector<GlobalVariable *>
>>>> &NameVars,
>>>> - std::string &Result, bool doCompression) {
>>>> +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));
>>>> @@ -275,8 +283,7 @@ collectPGOFuncNameStrings(const std::vec
>>>> 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());
>>>> @@ -294,7 +301,7 @@ std::error_code readPGOFuncNameStrings(S
>>>> 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());
>>>> @@ -313,7 +320,7 @@ std::error_code readPGOFuncNameStrings(S
>>>> P++;
>>>> }
>>>> Symtab.finalizeSymtab();
>>>> - return make_error_code(instrprof_error::success);
>>>> + return Error::success();
>>>> }
>>>>
>>>> void InstrProfValueSiteRecord::merge(SoftInstrProfErrors &SIPE,
>>>> @@ -577,45 +584,45 @@ static std::unique_ptr<ValueProfData> al
>>>> 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);
>>>> }
>>>>
>>>> Modified: llvm/trunk/lib/ProfileData/InstrProfReader.cpp
>>>> URL:
>>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ProfileData/InstrProfReader.cpp?rev=269491&r1=269490&r2=269491&view=diff
>>>>
>>>> ==============================================================================
>>>> --- llvm/trunk/lib/ProfileData/InstrProfReader.cpp (original)
>>>> +++ llvm/trunk/lib/ProfileData/InstrProfReader.cpp Fri May 13 16:50:56
>>>> 2016
>>>> @@ -18,33 +18,33 @@
>>>>
>>>> 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.
>>>> @@ -57,46 +57,49 @@ InstrProfReader::create(std::unique_ptr<
>>>> 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)) {
>>>>
>>> + // Handle errors in the reader.
>>>> + InstrProfError::take(std::move(E));
>>>> *this = InstrProfIterator();
>>>> + }
>>>> }
>>>>
>>>> bool TextInstrProfReader::hasFormat(const MemoryBuffer &Buffer) {
>>>> @@ -112,7 +115,7 @@ bool TextInstrProfReader::hasFormat(cons
>>>> // 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(":")) {
>>>> @@ -125,14 +128,14 @@ std::error_code TextInstrProfReader::rea
>>>> 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)
>>>> \
>>>> @@ -196,7 +199,7 @@ TextInstrProfReader::readValueProfileDat
>>>> #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;
>>>> @@ -238,8 +241,8 @@ std::error_code TextInstrProfReader::rea
>>>> }
>>>>
>>>> // 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.
>>>> @@ -258,7 +261,7 @@ bool RawInstrProfReader<IntPtrT>::hasFor
>>>> }
>>>>
>>>> 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))
>>>> @@ -270,26 +273,25 @@ std::error_code RawInstrProfReader<IntPt
>>>> }
>>>>
>>>> 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);
>>>> @@ -297,11 +299,9 @@ RawInstrProfReader<IntPtrT>::readNextHea
>>>> }
>>>>
>>>> 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)
>>>> @@ -313,8 +313,8 @@ RawInstrProfReader<IntPtrT>::createSymta
>>>> }
>>>>
>>>> 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);
>>>> @@ -346,28 +346,27 @@ RawInstrProfReader<IntPtrT>::readHeader(
>>>> 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;
>>>> @@ -394,8 +393,8 @@ std::error_code RawInstrProfReader<IntPt
>>>> }
>>>>
>>>> template <class IntPtrT>
>>>> -std::error_code
>>>> -RawInstrProfReader<IntPtrT>::readValueProfilingData(InstrProfRecord
>>>> &Record) {
>>>> +Error RawInstrProfReader<IntPtrT>::readValueProfilingData(
>>>> + InstrProfRecord &Record) {
>>>>
>>>> Record.clearValueData();
>>>> CurValueDataSize = 0;
>>>> @@ -407,13 +406,13 @@ RawInstrProfReader<IntPtrT>::readValuePr
>>>> 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
>>>
>>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160514/0d191d43/attachment.html>
More information about the llvm-commits
mailing list