[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:46:26 PDT 2016
And the corresponding Clang and compiler-rt commits in r269549 and r269550
resp.
On Fri, May 13, 2016 at 11:32 PM Chandler Carruth <chandlerc at google.com>
wrote:
> 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->
>>>>
>>>>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160514/092e5a46/attachment-0001.html>
More information about the llvm-commits
mailing list