[llvm] r269491 - Retry "[ProfileData] (llvm) Use Error in InstrProf and Coverage, NFC"
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Fri May 13 18:13:01 PDT 2016
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 from the raw profile
> are
> @@ -424,28 +423,27 @@ RawInstrProfReader<IntPtrT>::readValuePr
> }
>
> template <class IntPtrT>
> -std::error_code
> -RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord &Record) {
> +Error RawInstrProfReader<IntPtrT>::readNextRecord(InstrProfRecord
> &Record) {
> if (atEnd())
> // At this point, ValueDataStart field points to the next header.
> - if (std::error_code EC = readNextHeader(getNextHeaderPos()))
> - return EC;
> + if (Error E = readNextHeader(getNextHeaderPos()))
> + return E;
>
> // Read name ad set it in Record.
> - if (std::error_code EC = readName(Record))
> - return EC;
> + if (Error E = readName(Record))
> + return E;
>
> // Read FuncHash and set it in Record.
> - if (std::error_code EC = readFuncHash(Record))
> - return EC;
> + if (Error E = readFuncHash(Record))
> + return E;
>
> // Read raw counts and set Record.
> - if (std::error_code EC = readRawCounts(Record))
> - return EC;
> + if (Error E = readRawCounts(Record))
> + return E;
>
> // Read value data and set Record.
> - if (std::error_code EC = readValueProfilingData(Record))
> - return EC;
> + if (Error E = readValueProfilingData(Record))
> + return E;
>
> // Iterate.
> advanceData();
> @@ -467,10 +465,10 @@ typedef InstrProfLookupTrait::offset_typ
>
> bool InstrProfLookupTrait::readValueProfilingData(
> const unsigned char *&D, const unsigned char *const End) {
> - ErrorOr<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
> + Expected<std::unique_ptr<ValueProfData>> VDataPtrOrErr =
> ValueProfData::getValueProfData(D, End, ValueProfDataEndianness);
>
> - if (VDataPtrOrErr.getError())
> + if (VDataPtrOrErr.takeError())
> return false;
>
> VDataPtrOrErr.get()->deserializeTo(DataBuffer.back(), nullptr);
> @@ -526,31 +524,31 @@ data_type InstrProfLookupTrait::ReadData
> }
>
> template <typename HashTableImpl>
> -std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
> +Error InstrProfReaderIndex<HashTableImpl>::getRecords(
> StringRef FuncName, ArrayRef<InstrProfRecord> &Data) {
> auto Iter = HashTable->find(FuncName);
> if (Iter == HashTable->end())
> - return instrprof_error::unknown_function;
> + return make_error<InstrProfError>(instrprof_error::unknown_function);
>
> Data = (*Iter);
> if (Data.empty())
> - return instrprof_error::malformed;
> + return make_error<InstrProfError>(instrprof_error::malformed);
>
> - return instrprof_error::success;
> + return Error::success();
> }
>
> template <typename HashTableImpl>
> -std::error_code InstrProfReaderIndex<HashTableImpl>::getRecords(
> +Error InstrProfReaderIndex<HashTableImpl>::getRecords(
> ArrayRef<InstrProfRecord> &Data) {
> if (atEnd())
> - return instrprof_error::eof;
> + return make_error<InstrProfError>(instrprof_error::eof);
>
> Data = *RecordIterator;
>
> if (Data.empty())
> - return instrprof_error::malformed;
> + return make_error<InstrProfError>(instrprof_error::malformed);
>
> - return instrprof_error::success;
> + return Error::success();
> }
>
> template <typename HashTableImpl>
> @@ -609,7 +607,7 @@ IndexedInstrProfReader::readSummary(Inde
> }
> }
>
> -std::error_code IndexedInstrProfReader::readHeader() {
> +Error IndexedInstrProfReader::readHeader() {
> const unsigned char *Start =
> (const unsigned char *)DataBuffer->getBufferStart();
> const unsigned char *Cur = Start;
> @@ -661,13 +659,13 @@ InstrProfSymtab &IndexedInstrProfReader:
> return *Symtab.get();
> }
>
> -ErrorOr<InstrProfRecord>
> +Expected<InstrProfRecord>
> IndexedInstrProfReader::getInstrProfRecord(StringRef FuncName,
> uint64_t FuncHash) {
> ArrayRef<InstrProfRecord> Data;
> - std::error_code EC = Index->getRecords(FuncName, Data);
> - if (EC != instrprof_error::success)
> - return EC;
> + Error Err = Index->getRecords(FuncName, Data);
> + if (Err)
> + return std::move(Err);
> // Found it. Look for counters with the right hash.
> for (unsigned I = 0, E = Data.size(); I < E; ++I) {
> // Check for a match and fill the vector if there is one.
> @@ -678,26 +676,25 @@ IndexedInstrProfReader::getInstrProfReco
> return error(instrprof_error::hash_mismatch);
> }
>
> -std::error_code
> -IndexedInstrProfReader::getFunctionCounts(StringRef FuncName, uint64_t
> FuncHash,
> - std::vector<uint64_t> &Counts) {
> - ErrorOr<InstrProfRecord> Record = getInstrProfRecord(FuncName,
> FuncHash);
> - if (std::error_code EC = Record.getError())
> - return EC;
> +Error IndexedInstrProfReader::getFunctionCounts(StringRef FuncName,
> + uint64_t FuncHash,
> + std::vector<uint64_t>
> &Counts) {
> + Expected<InstrProfRecord> Record = getInstrProfRecord(FuncName,
> FuncHash);
> + if (Error E = Record.takeError())
> + return error(std::move(E));
>
> Counts = Record.get().Counts;
> return success();
> }
>
> -std::error_code IndexedInstrProfReader::readNextRecord(
> - InstrProfRecord &Record) {
> +Error IndexedInstrProfReader::readNextRecord(InstrProfRecord &Record) {
> static unsigned RecordIndex = 0;
>
> ArrayRef<InstrProfRecord> Data;
>
> - std::error_code EC = Index->getRecords(Data);
> - if (EC != instrprof_error::success)
> - return error(EC);
> + Error E = Index->getRecords(Data);
> + if (E)
> + return error(std::move(E));
>
> Record = Data[RecordIndex++];
> if (RecordIndex >= Data.size()) {
>
> Modified: llvm/trunk/lib/ProfileData/InstrProfWriter.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/ProfileData/InstrProfWriter.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/ProfileData/InstrProfWriter.cpp (original)
> +++ llvm/trunk/lib/ProfileData/InstrProfWriter.cpp Fri May 13 16:50:56 2016
> @@ -156,8 +156,7 @@ void InstrProfWriter::setOutputSparse(bo
> this->Sparse = Sparse;
> }
>
> -std::error_code InstrProfWriter::addRecord(InstrProfRecord &&I,
> - uint64_t Weight) {
> +Error InstrProfWriter::addRecord(InstrProfRecord &&I, uint64_t Weight) {
> auto &ProfileDataMap = FunctionData[I.Name];
>
> bool NewFunc;
> @@ -180,7 +179,7 @@ std::error_code InstrProfWriter::addReco
>
> Dest.sortValueData();
>
> - return Dest.getError();
> + return Dest.takeError();
> }
>
> bool InstrProfWriter::shouldEncodeData(const ProfilingData &PD) {
>
> Modified: llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp (original)
> +++ llvm/trunk/lib/Transforms/Instrumentation/InstrProfiling.cpp Fri May
> 13 16:50:56 2016
> @@ -374,9 +374,9 @@ void InstrProfiling::emitNameData() {
> return;
>
> std::string CompressedNameStr;
> - if (auto EC = collectPGOFuncNameStrings(ReferencedNames,
> CompressedNameStr,
> + if (Error E = collectPGOFuncNameStrings(ReferencedNames,
> CompressedNameStr,
> DoNameCompression)) {
> - llvm::report_fatal_error(EC.message(), false);
> + llvm::report_fatal_error(toString(std::move(E)), false);
> }
>
> auto &Ctx = M->getContext();
>
> Modified: llvm/trunk/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Instrumentation/PGOInstrumentation.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/lib/Transforms/Instrumentation/PGOInstrumentation.cpp
> (original)
> +++ llvm/trunk/lib/Transforms/Instrumentation/PGOInstrumentation.cpp Fri
> May 13 16:50:56 2016
> @@ -582,23 +582,28 @@ void PGOUseFunc::setEdgeCount(DirectEdge
> // Return true if the profile are successfully read, and false on errors.
> bool PGOUseFunc::readCounters(IndexedInstrProfReader *PGOReader) {
> auto &Ctx = M->getContext();
> - ErrorOr<InstrProfRecord> Result =
> + Expected<InstrProfRecord> Result =
> PGOReader->getInstrProfRecord(FuncInfo.FuncName,
> FuncInfo.FunctionHash);
> - if (std::error_code EC = Result.getError()) {
> - if (EC == instrprof_error::unknown_function) {
> - NumOfPGOMissing++;
> - if (NoPGOWarnMissing)
> - return false;
> - } else if (EC == instrprof_error::hash_mismatch ||
> - EC == llvm::instrprof_error::malformed) {
> - NumOfPGOMismatch++;
> - if (NoPGOWarnMismatch)
> - return false;
> - }
> + if (Error E = Result.takeError()) {
> + handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
> + auto Err = IPE.get();
> + bool SkipWarning = false;
> + if (Err == instrprof_error::unknown_function) {
> + NumOfPGOMissing++;
> + SkipWarning = NoPGOWarnMissing;
> + } else if (Err == instrprof_error::hash_mismatch ||
> + Err == instrprof_error::malformed) {
> + NumOfPGOMismatch++;
> + SkipWarning = NoPGOWarnMismatch;
> + }
>
> - std::string Msg = EC.message() + std::string(" ") + F.getName().str();
> - Ctx.diagnose(
> - DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
> + if (SkipWarning)
> + return;
> +
> + std::string Msg = IPE.message() + std::string(" ") +
> F.getName().str();
> + Ctx.diagnose(
> + DiagnosticInfoPGOProfile(M->getName().data(), Msg, DS_Warning));
> + });
> return false;
> }
> ProfileRecord = std::move(Result.get());
> @@ -854,9 +859,11 @@ static bool annotateAllFunctions(
> auto &Ctx = M.getContext();
> // Read the counter array from file.
> auto ReaderOrErr = IndexedInstrProfReader::create(ProfileFileName);
> - if (std::error_code EC = ReaderOrErr.getError()) {
> - Ctx.diagnose(
> - DiagnosticInfoPGOProfile(ProfileFileName.data(), EC.message()));
> + if (Error E = ReaderOrErr.takeError()) {
> + handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
> + Ctx.diagnose(
> + DiagnosticInfoPGOProfile(ProfileFileName.data(), EI.message()));
> + });
> return false;
> }
>
>
> Modified: llvm/trunk/tools/llvm-cov/CodeCoverage.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-cov/CodeCoverage.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/tools/llvm-cov/CodeCoverage.cpp (original)
> +++ llvm/trunk/tools/llvm-cov/CodeCoverage.cpp Fri May 13 16:50:56 2016
> @@ -210,10 +210,9 @@ std::unique_ptr<CoverageMapping> CodeCov
> errs() << "warning: profile data may be out of date - object is
> newer\n";
> auto CoverageOrErr = CoverageMapping::load(ObjectFilename, PGOFilename,
> CoverageArch);
> - if (std::error_code EC = CoverageOrErr.getError()) {
> + if (Error E = CoverageOrErr.takeError()) {
> colored_ostream(errs(), raw_ostream::RED)
> - << "error: Failed to load coverage: " << EC.message();
> - errs() << "\n";
> + << "error: Failed to load coverage: " << toString(std::move(E))
> << "\n";
> return nullptr;
> }
> auto Coverage = std::move(CoverageOrErr.get());
>
> Modified: llvm/trunk/tools/llvm-profdata/llvm-profdata.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/tools/llvm-profdata/llvm-profdata.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/tools/llvm-profdata/llvm-profdata.cpp (original)
> +++ llvm/trunk/tools/llvm-profdata/llvm-profdata.cpp Fri May 13 16:50:56
> 2016
> @@ -47,38 +47,50 @@ static void exitWithError(const Twine &M
> ::exit(1);
> }
>
> -static void exitWithErrorCode(const std::error_code &Error,
> - StringRef Whence = "") {
> - if (Error.category() == instrprof_category()) {
> - instrprof_error instrError =
> static_cast<instrprof_error>(Error.value());
> - if (instrError == instrprof_error::unrecognized_format) {
> - // Hint for common error of forgetting -sample for sample profiles.
> - exitWithError(Error.message(), Whence,
> - "Perhaps you forgot to use the -sample option?");
> - }
> +static void exitWithError(Error E, StringRef Whence = "") {
> + if (E.isA<InstrProfError>()) {
> + handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
> + instrprof_error instrError = IPE.get();
> + StringRef Hint = "";
> + if (instrError == instrprof_error::unrecognized_format) {
> + // Hint for common error of forgetting -sample for sample
> profiles.
> + Hint = "Perhaps you forgot to use the -sample option?";
> + }
> + exitWithError(IPE.message(), Whence, Hint);
> + });
> }
> - exitWithError(Error.message(), Whence);
> +
> + exitWithError(toString(std::move(E)), Whence);
> +}
> +
> +static void exitWithErrorCode(std::error_code EC, StringRef Whence = "") {
> + exitWithError(EC.message(), Whence);
> }
>
> namespace {
> enum ProfileKinds { instr, sample };
> }
>
> -static void handleMergeWriterError(std::error_code &Error,
> - StringRef WhenceFile = "",
> +static void handleMergeWriterError(Error E, StringRef WhenceFile = "",
> StringRef WhenceFunction = "",
> bool ShowHint = true) {
> if (!WhenceFile.empty())
> errs() << WhenceFile << ": ";
> if (!WhenceFunction.empty())
> errs() << WhenceFunction << ": ";
> - errs() << Error.message() << "\n";
> +
> + auto IPE = instrprof_error::success;
> + E = handleErrors(std::move(E),
> + [&IPE](std::unique_ptr<InstrProfError> E) -> Error {
> + IPE = E->get();
> + return Error(std::move(E));
> + });
> + errs() << toString(std::move(E)) << "\n";
>
> if (ShowHint) {
> StringRef Hint = "";
> - if (Error.category() == instrprof_category()) {
> - instrprof_error instrError =
> static_cast<instrprof_error>(Error.value());
> - switch (instrError) {
> + if (IPE != instrprof_error::success) {
> + switch (IPE) {
> case instrprof_error::hash_mismatch:
> case instrprof_error::count_mismatch:
> case instrprof_error::value_site_count_mismatch:
> @@ -120,11 +132,11 @@ static void mergeInstrProfile(const Weig
> exitWithErrorCode(EC, OutputFilename);
>
> InstrProfWriter Writer(OutputSparse);
> - SmallSet<std::error_code, 4> WriterErrorCodes;
> + SmallSet<instrprof_error, 4> WriterErrorCodes;
> for (const auto &Input : Inputs) {
> auto ReaderOrErr = InstrProfReader::create(Input.Filename);
> - if (std::error_code ec = ReaderOrErr.getError())
> - exitWithErrorCode(ec, Input.Filename);
> + if (Error E = ReaderOrErr.takeError())
> + exitWithError(std::move(E), Input.Filename);
>
> auto Reader = std::move(ReaderOrErr.get());
> bool IsIRProfile = Reader->isIRLevelProfile();
> @@ -132,14 +144,16 @@ static void mergeInstrProfile(const Weig
> exitWithError("Merge IR generated profile with Clang generated
> profile.");
>
> for (auto &I : *Reader) {
> - if (std::error_code EC = Writer.addRecord(std::move(I),
> Input.Weight)) {
> + if (Error E = Writer.addRecord(std::move(I), Input.Weight)) {
> // Only show hint the first time an error occurs.
> - bool firstTime = WriterErrorCodes.insert(EC).second;
> - handleMergeWriterError(EC, Input.Filename, I.Name, firstTime);
> + instrprof_error IPE = InstrProfError::take(std::move(E));
> + bool firstTime = WriterErrorCodes.insert(IPE).second;
> + handleMergeWriterError(make_error<InstrProfError>(IPE),
> Input.Filename,
> + I.Name, firstTime);
> }
> }
> if (Reader->hasError())
> - exitWithErrorCode(Reader->getError(), Input.Filename);
> + exitWithError(Reader->getError(), Input.Filename);
> }
> if (OutputFormat == PF_Text)
> Writer.writeText(Output);
> @@ -187,7 +201,7 @@ static void mergeSampleProfile(const Wei
> sampleprof_error Result = ProfileMap[FName].merge(Samples,
> Input.Weight);
> if (Result != sampleprof_error::success) {
> std::error_code EC = make_error_code(Result);
> - handleMergeWriterError(EC, Input.Filename, FName);
> + handleMergeWriterError(errorCodeToError(EC), Input.Filename,
> FName);
> }
> }
> }
> @@ -268,8 +282,8 @@ static int showInstrProfile(std::string
> Cutoffs = {800000, 900000, 950000, 990000, 999000, 999900, 999990};
> }
> InstrProfSummary PS(Cutoffs);
> - if (std::error_code EC = ReaderOrErr.getError())
> - exitWithErrorCode(EC, Filename);
> + if (Error E = ReaderOrErr.takeError())
> + exitWithError(std::move(E), Filename);
>
> auto Reader = std::move(ReaderOrErr.get());
> bool IsIRInstr = Reader->isIRLevelProfile();
> @@ -335,7 +349,7 @@ static int showInstrProfile(std::string
> }
>
> if (Reader->hasError())
> - exitWithErrorCode(Reader->getError(), Filename);
> + exitWithError(Reader->getError(), Filename);
>
> if (ShowCounts && TextFormat)
> return 0;
>
> Modified: llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp (original)
> +++ llvm/trunk/unittests/ProfileData/CoverageMappingTest.cpp Fri May 13
> 16:50:56 2016
> @@ -20,11 +20,11 @@
> using namespace llvm;
> using namespace coverage;
>
> -static ::testing::AssertionResult NoError(std::error_code EC) {
> - if (!EC)
> +static ::testing::AssertionResult NoError(Error E) {
> + if (!E)
> return ::testing::AssertionSuccess();
> - return ::testing::AssertionFailure() << "error " << EC.value()
> - << ": " << EC.message();
> + return ::testing::AssertionFailure() << "error: " <<
> toString(std::move(E))
> + << "\n";
> }
>
> namespace llvm {
> @@ -70,14 +70,14 @@ struct CoverageMappingReaderMock : Cover
> CoverageMappingReaderMock(ArrayRef<OutputFunctionCoverageData>
> Functions)
> : Functions(Functions) {}
>
> - std::error_code readNextRecord(CoverageMappingRecord &Record) override {
> + Error readNextRecord(CoverageMappingRecord &Record) override {
> if (Functions.empty())
> - return coveragemap_error::eof;
> + return make_error<CoverageMapError>(coveragemap_error::eof);
>
> Functions.front().fillCoverageMappingRecord(Record);
> Functions = Functions.slice(1);
>
> - return coveragemap_error::success;
> + return Error::success();
> }
> };
>
> @@ -190,7 +190,7 @@ struct CoverageMappingTest : ::testing::
> void readProfCounts() {
> auto Profile = ProfileWriter.writeBuffer();
> auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
> - ASSERT_TRUE(NoError(ReaderOrErr.getError()));
> + ASSERT_TRUE(NoError(ReaderOrErr.takeError()));
> ProfileReader = std::move(ReaderOrErr.get());
> }
>
> @@ -200,7 +200,7 @@ struct CoverageMappingTest : ::testing::
>
> CoverageMappingReaderMock CovReader(OutputFunctions);
> auto CoverageOrErr = CoverageMapping::load(CovReader, *ProfileReader);
> - ASSERT_TRUE(NoError(CoverageOrErr.getError()));
> + ASSERT_TRUE(NoError(CoverageOrErr.takeError()));
> LoadedCoverage = std::move(CoverageOrErr.get());
> }
> };
>
> Modified: llvm/trunk/unittests/ProfileData/InstrProfTest.cpp
> URL:
> http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/ProfileData/InstrProfTest.cpp?rev=269491&r1=269490&r2=269491&view=diff
>
> ==============================================================================
> --- llvm/trunk/unittests/ProfileData/InstrProfTest.cpp (original)
> +++ llvm/trunk/unittests/ProfileData/InstrProfTest.cpp Fri May 13 16:50:56
> 2016
> @@ -19,19 +19,24 @@
>
> using namespace llvm;
>
> -static ::testing::AssertionResult NoError(std::error_code EC) {
> - if (!EC)
> +static ::testing::AssertionResult NoError(Error E) {
> + if (!E)
> return ::testing::AssertionSuccess();
> - return ::testing::AssertionFailure() << "error " << EC.value()
> - << ": " << EC.message();
> + return ::testing::AssertionFailure() << "error: " <<
> toString(std::move(E))
> + << "\n";
> }
>
> -static ::testing::AssertionResult ErrorEquals(std::error_code Expected,
> - std::error_code Found) {
> +static ::testing::AssertionResult ErrorEquals(instrprof_error Expected,
> + Error E) {
> + instrprof_error Found;
> + std::string FoundMsg;
> + handleAllErrors(std::move(E), [&](const InstrProfError &IPE) {
> + Found = IPE.get();
> + FoundMsg = IPE.message();
> + });
> if (Expected == Found)
> return ::testing::AssertionSuccess();
> - return ::testing::AssertionFailure() << "error " << Found.value()
> - << ": " << Found.message();
> + return ::testing::AssertionFailure() << "error: " << FoundMsg << "\n";
> }
>
> namespace {
> @@ -44,7 +49,7 @@ struct InstrProfTest : ::testing::Test {
>
> void readProfile(std::unique_ptr<MemoryBuffer> Profile) {
> auto ReaderOrErr = IndexedInstrProfReader::create(std::move(Profile));
> - ASSERT_TRUE(NoError(ReaderOrErr.getError()));
> + ASSERT_TRUE(NoError(ReaderOrErr.takeError()));
> Reader = std::move(ReaderOrErr.get());
> }
> };
> @@ -90,23 +95,23 @@ TEST_P(MaybeSparseInstrProfTest, get_ins
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("foo", 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("foo", 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(2U, R->Counts.size());
> ASSERT_EQ(1U, R->Counts[0]);
> ASSERT_EQ(2U, R->Counts[1]);
>
> R = Reader->getInstrProfRecord("foo", 0x1235);
> - ASSERT_TRUE(NoError(R.getError()));
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(2U, R->Counts.size());
> ASSERT_EQ(3U, R->Counts[0]);
> ASSERT_EQ(4U, R->Counts[1]);
>
> R = Reader->getInstrProfRecord("foo", 0x5678);
> - ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.getError()));
> + ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, R.takeError()));
>
> R = Reader->getInstrProfRecord("bar", 0x1234);
> - ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function,
> R.getError()));
> + ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function,
> R.takeError()));
> }
>
> TEST_P(MaybeSparseInstrProfTest, get_function_counts) {
> @@ -128,12 +133,11 @@ TEST_P(MaybeSparseInstrProfTest, get_fun
> ASSERT_EQ(3U, Counts[0]);
> ASSERT_EQ(4U, Counts[1]);
>
> - std::error_code EC;
> - EC = Reader->getFunctionCounts("foo", 0x5678, Counts);
> - ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, EC));
> + Error E1 = Reader->getFunctionCounts("foo", 0x5678, Counts);
> + ASSERT_TRUE(ErrorEquals(instrprof_error::hash_mismatch, std::move(E1)));
>
> - EC = Reader->getFunctionCounts("bar", 0x1234, Counts);
> - ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function, EC));
> + Error E2 = Reader->getFunctionCounts("bar", 0x1234, Counts);
> + ASSERT_TRUE(ErrorEquals(instrprof_error::unknown_function,
> std::move(E2)));
> }
>
> // Profile data is copied from general.proftext
> @@ -235,8 +239,8 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
> ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
> ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
> @@ -266,8 +270,8 @@ TEST_P(MaybeSparseInstrProfTest, annotat
> NoError(Writer.addRecord(std::move(Record)));
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
>
> LLVMContext Ctx;
> std::unique_ptr<Module> M(new Module("MyModule", Ctx));
> @@ -378,8 +382,8 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
> ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
> ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
> @@ -431,8 +435,8 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> // Set big endian input.
> Reader->setValueProfDataEndianness(support::big);
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(4U, R->getNumValueSites(IPVK_IndirectCallTarget));
> ASSERT_EQ(3U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
> ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
> @@ -513,8 +517,8 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> ASSERT_EQ(5U, R->getNumValueSites(IPVK_IndirectCallTarget));
> ASSERT_EQ(4U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 0));
> ASSERT_EQ(0U, R->getNumValueDataForSite(IPVK_IndirectCallTarget, 1));
> @@ -566,23 +570,27 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
>
> InstrProfRecord Record1("foo", 0x1234, {1});
> auto Result1 = Writer.addRecord(std::move(Record1));
> - ASSERT_EQ(Result1, instrprof_error::success);
> + ASSERT_EQ(InstrProfError::take(std::move(Result1)),
> + instrprof_error::success);
>
> // Verify counter overflow.
> InstrProfRecord Record2("foo", 0x1234, {Max});
> auto Result2 = Writer.addRecord(std::move(Record2));
> - ASSERT_EQ(Result2, instrprof_error::counter_overflow);
> + ASSERT_EQ(InstrProfError::take(std::move(Result2)),
> + instrprof_error::counter_overflow);
>
> InstrProfRecord Record3(bar, 0x9012, {8});
> auto Result3 = Writer.addRecord(std::move(Record3));
> - ASSERT_EQ(Result3, instrprof_error::success);
> + ASSERT_EQ(InstrProfError::take(std::move(Result3)),
> + instrprof_error::success);
>
> InstrProfRecord Record4("baz", 0x5678, {3, 4});
> Record4.reserveSites(IPVK_IndirectCallTarget, 1);
> InstrProfValueData VD4[] = {{uint64_t(bar), 1}};
> Record4.addValueData(IPVK_IndirectCallTarget, 0, VD4, 1, nullptr);
> auto Result4 = Writer.addRecord(std::move(Record4));
> - ASSERT_EQ(Result4, instrprof_error::success);
> + ASSERT_EQ(InstrProfError::take(std::move(Result4)),
> + instrprof_error::success);
>
> // Verify value data counter overflow.
> InstrProfRecord Record5("baz", 0x5678, {5, 6});
> @@ -590,19 +598,21 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> InstrProfValueData VD5[] = {{uint64_t(bar), Max}};
> Record5.addValueData(IPVK_IndirectCallTarget, 0, VD5, 1, nullptr);
> auto Result5 = Writer.addRecord(std::move(Record5));
> - ASSERT_EQ(Result5, instrprof_error::counter_overflow);
> + ASSERT_EQ(InstrProfError::take(std::move(Result5)),
> + instrprof_error::counter_overflow);
>
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> // Verify saturation of counts.
> - ErrorOr<InstrProfRecord> ReadRecord1 =
> + Expected<InstrProfRecord> ReadRecord1 =
> Reader->getInstrProfRecord("foo", 0x1234);
> - ASSERT_TRUE(NoError(ReadRecord1.getError()));
> + ASSERT_TRUE(NoError(ReadRecord1.takeError()));
> ASSERT_EQ(Max, ReadRecord1->Counts[0]);
>
> - ErrorOr<InstrProfRecord> ReadRecord2 =
> + Expected<InstrProfRecord> ReadRecord2 =
> Reader->getInstrProfRecord("baz", 0x5678);
> + ASSERT_TRUE(bool(ReadRecord2));
> ASSERT_EQ(1U, ReadRecord2->getNumValueSites(IPVK_IndirectCallTarget));
> std::unique_ptr<InstrProfValueData[]> VD =
> ReadRecord2->getValueForSite(IPVK_IndirectCallTarget, 0);
> @@ -647,8 +657,8 @@ TEST_P(MaybeSparseInstrProfTest, get_ica
> auto Profile = Writer.writeBuffer();
> readProfile(std::move(Profile));
>
> - ErrorOr<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> - ASSERT_TRUE(NoError(R.getError()));
> + Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller",
> 0x1234);
> + ASSERT_TRUE(NoError(R.takeError()));
> std::unique_ptr<InstrProfValueData[]> VD(
> R->getValueForSite(IPVK_IndirectCallTarget, 0));
> ASSERT_EQ(2U, R->getNumValueSites(IPVK_IndirectCallTarget));
>
>
> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
--
~Craig
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160513/ab6dacea/attachment-0001.html>
More information about the llvm-commits
mailing list