[ELF] Move ELF.h to Expected<T>

[davide]

Summary

The tests still need to be updated. Before doing that, I would like to get another pair of eyes on the new error messages, in order to avoid to change them many times. Other than that, the transition is complete.

[• rafael]

This enables quite a few followup cleanups, so LGTM with just a few nits.

include/llvm/Object/ELF.h

172

At some point this should all be inconvertibleErrorCode. For now, can you always use object_error::parse_failed? With the string we don't need the various enums.

How about for now just adding a helper function:

static StringError createError(StringRef Err) {

return make_error<StringError>(Err, object_error::parse_failed);

}

That way we only have to update one place in a followup patch.

387

You don't need this comment anymore.

tools/llvm-objdump/llvm-objdump.cpp

621

This is in tools, I wonder why it doesn't just fail fast. In any case, that is for another patch.

tools/llvm-readobj/ARMEHABIPrinter.h

354

Don't we have an error that takes an Error so that you don't have to call errorToErrorCode?

[Bigcheese]

Looks fine with the following wording changes and what rafael requested.

include/llvm/Object/ELF.h

267

invalid section offset

414

invalid section offset

432

invalid sh_type for string table, expected SHT_STRTAB

494

invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM

521

invalid string offset

[davide]

include/llvm/Object/ELF.h

172

I thought the same (about using parse_failed everywhere, but wanted to do in a follow-up). Anyway, it's a good idea so I did it now.

267

Thanks for auditing the message, Spency

387

Done.

tools/llvm-objdump/llvm-objdump.cpp

621

I agree. Not quite fond of llvm-objdump, I'll open a bug.

tools/llvm-readobj/ARMEHABIPrinter.h

354

Yes, we do. In fact, I used it 10 lines below, but I forgot here =)

[davide]

Committed upstream. I find amusing that I found a thread where we discussed this more than one year ago (I completely forgot about it) =)
http://lists.llvm.org/pipermail/llvm-commits/Week-of-Mon-20150810/293003.html

include/llvm/Object/ELF.h

private:
   StringRef Buf;
 
 public:
   const Elf_Ehdr *getHeader() const {
     return reinterpret_cast<const Elf_Ehdr *>(base());
   }
 
   template <typename T>
-  ErrorOr<const T *> getEntry(uint32_t Section, uint32_t Entry) const;
+  Expected<const T *> getEntry(uint32_t Section, uint32_t Entry) const;
   template <typename T>
-  ErrorOr<const T *> getEntry(const Elf_Shdr *Section, uint32_t Entry) const;
+  Expected<const T *> getEntry(const Elf_Shdr *Section, uint32_t Entry) const;
 
-  ErrorOr<StringRef> getStringTable(const Elf_Shdr *Section) const;
-  ErrorOr<StringRef> getStringTableForSymtab(const Elf_Shdr &Section) const;
-  ErrorOr<StringRef> getStringTableForSymtab(const Elf_Shdr &Section,
+  Expected<StringRef> getStringTable(const Elf_Shdr *Section) const;
+  Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section) const;
+  Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section,
                                               Elf_Shdr_Range Sections) const;
 
-  ErrorOr<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section) const;
-  ErrorOr<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section,
+  Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section) const;
+  Expected<ArrayRef<Elf_Word>> getSHNDXTable(const Elf_Shdr &Section,
                                              Elf_Shdr_Range Sections) const;
 
   void VerifyStrTab(const Elf_Shdr *sh) const;
 
   StringRef getRelocationTypeName(uint32_t Type) const;
   void getRelocationTypeName(uint32_t Type,
                              SmallVectorImpl<char> &Result) const;
 
   /// \brief Get the symbol for a given relocation.
-  ErrorOr<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
+  Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
                                                 const Elf_Shdr *SymTab) const;
 
   ELFFile(StringRef Object);
 
   bool isMipsELF64() const {
     return getHeader()->e_machine == ELF::EM_MIPS &&
            getHeader()->getFileClass() == ELF::ELFCLASS64;
   }
 
   bool isMips64EL() const {
     return getHeader()->e_machine == ELF::EM_MIPS &&
            getHeader()->getFileClass() == ELF::ELFCLASS64 &&
            getHeader()->getDataEncoding() == ELF::ELFDATA2LSB;
   }
 
-  ErrorOr<Elf_Shdr_Range> sections() const;
+  Expected<Elf_Shdr_Range> sections() const;
 
-  ErrorOr<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {
+  Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {
     if (!Sec)
       return makeArrayRef<Elf_Sym>(nullptr, nullptr);
     return getSectionContentsAsArray<Elf_Sym>(Sec);
   }
 
-  ErrorOr<Elf_Rela_Range> relas(const Elf_Shdr *Sec) const {
+  Expected<Elf_Rela_Range> relas(const Elf_Shdr *Sec) const {
     return getSectionContentsAsArray<Elf_Rela>(Sec);
   }
 
-  ErrorOr<Elf_Rel_Range> rels(const Elf_Shdr *Sec) const {
+  Expected<Elf_Rel_Range> rels(const Elf_Shdr *Sec) const {
     return getSectionContentsAsArray<Elf_Rel>(Sec);
   }
 
   /// \brief Iterate over program header table.
-  ErrorOr<Elf_Phdr_Range> program_headers() const {
+  Expected<Elf_Phdr_Range> program_headers() const {
     if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr))
-      return object_error::parse_failed;
+      return make_error<StringError>("invalid e_phentsize",
+                                     object_error::parse_failed);
     auto *Begin =
         reinterpret_cast<const Elf_Phdr *>(base() + getHeader()->e_phoff);
     return makeArrayRef(Begin, Begin + getHeader()->e_phnum);
   }
 
-  ErrorOr<StringRef> getSectionStringTable(Elf_Shdr_Range Sections) const;
-  ErrorOr<uint32_t> getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
+  Expected<StringRef> getSectionStringTable(Elf_Shdr_Range Sections) const;
+  Expected<uint32_t> getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
                                      ArrayRef<Elf_Word> ShndxTable) const;
-  ErrorOr<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
+  Expected<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
                                         const Elf_Shdr *SymTab,
                                         ArrayRef<Elf_Word> ShndxTable) const;
-  ErrorOr<const Elf_Shdr *> getSection(const Elf_Sym *Sym, Elf_Sym_Range Symtab,
+  Expected<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
+                                        Elf_Sym_Range Symtab,
                                         ArrayRef<Elf_Word> ShndxTable) const;
-  ErrorOr<const Elf_Shdr *> getSection(uint32_t Index) const;
+  Expected<const Elf_Shdr *> getSection(uint32_t Index) const;
 
-  ErrorOr<const Elf_Sym *> getSymbol(const Elf_Shdr *Sec,
+  Expected<const Elf_Sym *> getSymbol(const Elf_Shdr *Sec,
                                       uint32_t Index) const;
 
-  ErrorOr<StringRef> getSectionName(const Elf_Shdr *Section) const;
-  ErrorOr<StringRef> getSectionName(const Elf_Shdr *Section,
+  Expected<StringRef> getSectionName(const Elf_Shdr *Section) const;
+  Expected<StringRef> getSectionName(const Elf_Shdr *Section,
                                      StringRef DotShstrtab) const;
   template <typename T>
-  ErrorOr<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr *Sec) const;
-  ErrorOr<ArrayRef<uint8_t> > getSectionContents(const Elf_Shdr *Sec) const;
+  Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr *Sec) const;
+  Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
 };
 
 typedef ELFFile<ELFType<support::little, false>> ELF32LEFile;
 typedef ELFFile<ELFType<support::little, true>> ELF64LEFile;
 typedef ELFFile<ELFType<support::big, false>> ELF32BEFile;
 typedef ELFFile<ELFType<support::big, true>> ELF64BEFile;
 
 template <class ELFT>
-inline ErrorOr<const typename ELFT::Shdr *>
+inline Expected<const typename ELFT::Shdr *>
 getSection(typename ELFT::ShdrRange Sections, uint32_t Index) {
   if (Index >= Sections.size())
-    return object_error::invalid_section_index;
+    return make_error<StringError>("invalid section index",
+                                   object_error::invalid_section_index);
   return &Sections[Index];
 }
 
 template <class ELFT>
-inline ErrorOr<uint32_t>
+inline Expected<uint32_t>
 getExtendedSymbolTableIndex(const typename ELFT::Sym *Sym,
                             const typename ELFT::Sym *FirstSym,
                             ArrayRef<typename ELFT::Word> ShndxTable) {
   assert(Sym->st_shndx == ELF::SHN_XINDEX);
   unsigned Index = Sym - FirstSym;
   if (Index >= ShndxTable.size())
-    return object_error::parse_failed;
+    return make_error<StringError>("index past the end of the symbol table",
+                                   object_error::parse_failed);
   // The size of the table was checked in getSHNDXTable.
   return ShndxTable[Index];
 }
 
 template <class ELFT>
-ErrorOr<uint32_t>
+Expected<uint32_t>
 ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
                                ArrayRef<Elf_Word> ShndxTable) const {
   uint32_t Index = Sym->st_shndx;
   if (Index == ELF::SHN_XINDEX) {
     auto ErrorOrIndex = object::getExtendedSymbolTableIndex<ELFT>(
         Sym, Syms.begin(), ShndxTable);
-    if (std::error_code EC = ErrorOrIndex.getError())
-      return EC;
+    if (!ErrorOrIndex)
+      return ErrorOrIndex.takeError();
     return *ErrorOrIndex;
   }
   if (Index == ELF::SHN_UNDEF || Index >= ELF::SHN_LORESERVE)
     return 0;
   return Index;
 }
 
 template <class ELFT>
-ErrorOr<const typename ELFT::Shdr *>
+Expected<const typename ELFT::Shdr *>
 ELFFile<ELFT>::getSection(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
                           ArrayRef<Elf_Word> ShndxTable) const {
   auto SymsOrErr = symbols(SymTab);
-  if (std::error_code EC = SymsOrErr.getError())
-    return EC;
+  if (!SymsOrErr)
+    return SymsOrErr.takeError();
   return getSection(Sym, *SymsOrErr, ShndxTable);
 }
 
 template <class ELFT>
-ErrorOr<const typename ELFT::Shdr *>
+Expected<const typename ELFT::Shdr *>
 ELFFile<ELFT>::getSection(const Elf_Sym *Sym, Elf_Sym_Range Symbols,
                           ArrayRef<Elf_Word> ShndxTable) const {
-  ErrorOr<uint32_t> IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);
-  if (std::error_code EC = IndexOrErr.getError())
-    return EC;
+  auto IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);
+  if (!IndexOrErr)
+    return IndexOrErr.takeError();
   uint32_t Index = *IndexOrErr;
   if (Index == 0)
     return nullptr;
   auto SectionsOrErr = sections();
-  if (std::error_code EC = SectionsOrErr.getError())
-    return EC;
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
   return object::getSection<ELFT>(*SectionsOrErr, Index);
 }
 
 template <class ELFT>
-inline ErrorOr<const typename ELFT::Sym *>
+inline Expected<const typename ELFT::Sym *>
 getSymbol(typename ELFT::SymRange Symbols, uint32_t Index) {
   if (Index >= Symbols.size())
-    return object_error::invalid_symbol_index;
+    return make_error<StringError>("invalid symbol index",
+                                   object_error::invalid_symbol_index);
   return &Symbols[Index];
 }
 
 template <class ELFT>
-ErrorOr<const typename ELFT::Sym *>
+Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
   auto SymtabOrErr = symbols(Sec);
-  if (std::error_code EC = SymtabOrErr.getError())
-    return EC;
+  if (!SymtabOrErr)
+    return SymtabOrErr.takeError();
   return object::getSymbol<ELFT>(*SymtabOrErr, Index);
 }
 
 template <class ELFT>
 template <typename T>
-ErrorOr<ArrayRef<T>>
+Expected<ArrayRef<T>>
 ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
   if (Sec->sh_entsize != sizeof(T) && sizeof(T) != 1)
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid sh_entsize",
+                                   object_error::parse_failed);
 
   uintX_t Offset = Sec->sh_offset;
   uintX_t Size = Sec->sh_size;
 
   if (Size % sizeof(T))
-    return object_error::parse_failed;
+    return make_error<StringError>("size is not a multiple of sh_entsize",
+                                   object_error::parse_failed);
   if ((std::numeric_limits<uintX_t>::max() - Offset < Size) ||
       Offset + Size > Buf.size())
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid offset",
+                                   object_error::parse_failed);
 
   const T *Start = reinterpret_cast<const T *>(base() + Offset);
   return makeArrayRef(Start, Size / sizeof(T));
 }
 
 template <class ELFT>
-ErrorOr<ArrayRef<uint8_t>>
+Expected<ArrayRef<uint8_t>>
 ELFFile<ELFT>::getSectionContents(const Elf_Shdr *Sec) const {
   return getSectionContentsAsArray<uint8_t>(Sec);
 }
 
 template <class ELFT>
 StringRef ELFFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
   return getELFRelocationTypeName(getHeader()->e_machine, Type);
 }
if (!isMipsELF64()) {
 
     Name = getRelocationTypeName(Type3);
     Result.append(1, '/');
     Result.append(Name.begin(), Name.end());
   }
 }
 
 template <class ELFT>
-ErrorOr<const typename ELFT::Sym *>
+Expected<const typename ELFT::Sym *>
 ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel *Rel,
                                    const Elf_Shdr *SymTab) const {
   uint32_t Index = Rel->getSymbol(isMips64EL());
   if (Index == 0)
     return nullptr;
   return getEntry<Elf_Sym>(SymTab, Index);
 }
 
 template <class ELFT>
-ErrorOr<StringRef>
+Expected<StringRef>
 ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections) const {
   uint32_t Index = getHeader()->e_shstrndx;
   if (Index == ELF::SHN_XINDEX)
     Index = Sections[0].sh_link;
 
   if (!Index) // no section string table.
     return "";
   if (Index >= Sections.size())
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid section index",
+                                   object_error::parse_failed);
   return getStringTable(&Sections[Index]);
 }
 
 template <class ELFT>
 ELFFile<ELFT>::ELFFile(StringRef Object) : Buf(Object) {
   assert(sizeof(Elf_Ehdr) <= Buf.size() && "Invalid buffer");
 }
 
 template <class ELFT>
 static bool compareAddr(uint64_t VAddr, const Elf_Phdr_Impl<ELFT> *Phdr) {
   return VAddr < Phdr->p_vaddr;
 }
 
 template <class ELFT>
-ErrorOr<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
+Expected<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
   const uintX_t SectionTableOffset = getHeader()->e_shoff;
   if (SectionTableOffset == 0)
     return ArrayRef<Elf_Shdr>();
 
-  // Invalid section header entry size (e_shentsize) in ELF header
   if (getHeader()->e_shentsize != sizeof(Elf_Shdr))
-    return object_error::parse_failed;
+    return make_error<StringError>(
+        "invalid section header entry size (e_shentsize) in ELF header",
+        object_error::parse_failed);
 
   const uint64_t FileSize = Buf.size();
 
-  // Section header table goes past end of file!
   if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize)
-    return object_error::parse_failed;
+    return make_error<StringError>(
+        "section header table goes past the end of the file",
+        object_error::parse_failed);
 
   // Invalid address alignment of section headers
   if (SectionTableOffset & (alignof(Elf_Shdr) - 1))
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid alignment of section headers",
+                                   object_error::parse_failed);
 
   const Elf_Shdr *First =
       reinterpret_cast<const Elf_Shdr *>(base() + SectionTableOffset);
 
   uintX_t NumSections = getHeader()->e_shnum;
   if (NumSections == 0)
     NumSections = First->sh_size;
 
-  // Section table goes past end of file!
   if (NumSections > UINT64_MAX / sizeof(Elf_Shdr))
-    return object_error::parse_failed;
+    return make_error<StringError>("section table goes past the end of file",
+                                   object_error::parse_failed);
 
   const uint64_t SectionTableSize = NumSections * sizeof(Elf_Shdr);
 
   // Section table goes past end of file!
   if (SectionTableOffset + SectionTableSize > FileSize)
-    return object_error::parse_failed;
+    return make_error<StringError>("section table goes past the end of file",
+                                   object_error::parse_failed);
 
   return makeArrayRef(First, NumSections);
 }
 
 template <class ELFT>
 template <typename T>
-ErrorOr<const T *> ELFFile<ELFT>::getEntry(uint32_t Section,
+Expected<const T *> ELFFile<ELFT>::getEntry(uint32_t Section,
                                             uint32_t Entry) const {
-  ErrorOr<const Elf_Shdr *> Sec = getSection(Section);
-  if (std::error_code EC = Sec.getError())
-    return EC;
-  return getEntry<T>(*Sec, Entry);
+  auto SecOrErr = getSection(Section);
+  if (!SecOrErr)
+    return SecOrErr.takeError();
+  return getEntry<T>(*SecOrErr, Entry);
 }
 
 template <class ELFT>
 template <typename T>
-ErrorOr<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr *Section,
+Expected<const T *> ELFFile<ELFT>::getEntry(const Elf_Shdr *Section,
                                             uint32_t Entry) const {
   if (sizeof(T) != Section->sh_entsize)
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid sh_entsize",
+                                   object_error::parse_failed);
   size_t Pos = Section->sh_offset + Entry * sizeof(T);
   if (Pos + sizeof(T) > Buf.size())
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid offset",
+                                   object_error::parse_failed);
   return reinterpret_cast<const T *>(base() + Pos);
 }
 
 template <class ELFT>
-ErrorOr<const typename ELFT::Shdr *>
+Expected<const typename ELFT::Shdr *>
 ELFFile<ELFT>::getSection(uint32_t Index) const {
   auto TableOrErr = sections();
-  if (std::error_code EC = TableOrErr.getError())
-    return EC;
+  if (!TableOrErr)
+    return TableOrErr.takeError();
   return object::getSection<ELFT>(*TableOrErr, Index);
 }
 
 template <class ELFT>
-ErrorOr<StringRef>
+Expected<StringRef>
 ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section) const {
   if (Section->sh_type != ELF::SHT_STRTAB)
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid sh_type",
+                                   object_error::parse_failed);
   auto V = getSectionContentsAsArray<char>(Section);
-  if (std::error_code EC = V.getError())
-    return EC;
+  if (!V)
+    return V.takeError();
   ArrayRef<char> Data = *V;
   if (Data.empty())
-    return object_error::parse_failed;
+    return make_error<StringError>("empty string table",
+                                   object_error::parse_failed);
   if (Data.back() != '\0')
-    return object_error::string_table_non_null_end;
+    return make_error<StringError>("string table non-null terminated",
+                                   object_error::string_table_non_null_end);
   return StringRef(Data.begin(), Data.size());
 }
 
 template <class ELFT>
-ErrorOr<ArrayRef<typename ELFT::Word>>
+Expected<ArrayRef<typename ELFT::Word>>
 ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section) const {
   auto SectionsOrErr = sections();
-  if (std::error_code EC = SectionsOrErr.getError())
-    return EC;
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
   return getSHNDXTable(Section, *SectionsOrErr);
 }
 
 template <class ELFT>
-ErrorOr<ArrayRef<typename ELFT::Word>>
+Expected<ArrayRef<typename ELFT::Word>>
 ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section,
                              Elf_Shdr_Range Sections) const {
   assert(Section.sh_type == ELF::SHT_SYMTAB_SHNDX);
   auto VOrErr = getSectionContentsAsArray<Elf_Word>(&Section);
-  if (std::error_code EC = VOrErr.getError())
-    return EC;
+  if (!VOrErr)
+    return VOrErr.takeError();
   ArrayRef<Elf_Word> V = *VOrErr;
-  ErrorOr<const Elf_Shdr *> SymTableOrErr =
-      object::getSection<ELFT>(Sections, Section.sh_link);
-  if (std::error_code EC = SymTableOrErr.getError())
-    return EC;
+  auto SymTableOrErr = object::getSection<ELFT>(Sections, Section.sh_link);
+  if (!SymTableOrErr)
+    return SymTableOrErr.takeError();
   const Elf_Shdr &SymTable = **SymTableOrErr;
   if (SymTable.sh_type != ELF::SHT_SYMTAB &&
       SymTable.sh_type != ELF::SHT_DYNSYM)
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid sh_type",
+                                   object_error::parse_failed);
   if (V.size() != (SymTable.sh_size / sizeof(Elf_Sym)))
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid section contents size",
+                                   object_error::parse_failed);
   return V;
 }
 
 template <class ELFT>
-ErrorOr<StringRef>
+Expected<StringRef>
 ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec) const {
   auto SectionsOrErr = sections();
-  if (std::error_code EC = SectionsOrErr.getError())
-    return EC;
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
   return getStringTableForSymtab(Sec, *SectionsOrErr);
 }
 
 template <class ELFT>
-ErrorOr<StringRef>
+Expected<StringRef>
 ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec,
                                        Elf_Shdr_Range Sections) const {
 
   if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
-    return object_error::parse_failed;
-  ErrorOr<const Elf_Shdr *> SectionOrErr =
-      object::getSection<ELFT>(Sections, Sec.sh_link);
-  if (std::error_code EC = SectionOrErr.getError())
-    return EC;
+    return make_error<StringError>("invalid sh_type",
+                                   object_error::parse_failed);
+  auto SectionOrErr = object::getSection<ELFT>(Sections, Sec.sh_link);
+  if (!SectionOrErr)
+    return errorToErrorCode(SectionOrErr.takeError()).message();
   return getStringTable(*SectionOrErr);
 }
 
 template <class ELFT>
-ErrorOr<StringRef>
+Expected<StringRef>
 ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section) const {
   auto SectionsOrErr = sections();
-  if (std::error_code EC = SectionsOrErr.getError())
-    return EC;
-  ErrorOr<StringRef> Table = getSectionStringTable(*SectionsOrErr);
-  if (std::error_code EC = Table.getError())
-    return EC;
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
+  auto Table = getSectionStringTable(*SectionsOrErr);
+  if (!Table)
+    return Table.takeError();
   return getSectionName(Section, *Table);
 }
 
 template <class ELFT>
-ErrorOr<StringRef> ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
+Expected<StringRef> ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
                                                   StringRef DotShstrtab) const {
   uint32_t Offset = Section->sh_name;
   if (Offset == 0)
     return StringRef();
   if (Offset >= DotShstrtab.size())
-    return object_error::parse_failed;
+    return make_error<StringError>("invalid offset",
+                                   object_error::parse_failed);
   return StringRef(DotShstrtab.data() + Offset);
 }
 
 /// This function returns the hash value for a symbol in the .dynsym section
 /// Name of the API remains consistent as specified in the libelf
 /// REF : http://www.sco.com/developers/gabi/latest/ch5.dynamic.html#hash
 inline unsigned hashSysV(StringRef SymbolName) {
   unsigned h = 0, g;

include/llvm/Object/ELFObjectFile.h

protected:
 
   uint32_t getSectionType(DataRefImpl Sec) const override;
   uint64_t getSectionFlags(DataRefImpl Sec) const override;
   uint64_t getSectionOffset(DataRefImpl Sec) const override;
   StringRef getRelocationTypeName(uint32_t Type) const;
 
   /// \brief Get the relocation section that contains \a Rel.
   const Elf_Shdr *getRelSection(DataRefImpl Rel) const {
-    return *EF.getSection(Rel.d.a);
+    auto RelSecOrErr = EF.getSection(Rel.d.a);
+    if (!RelSecOrErr)
+      return nullptr;
+    return *RelSecOrErr;
   }
 
   DataRefImpl toDRI(const Elf_Shdr *SymTable, unsigned SymbolNum) const {
     DataRefImpl DRI;
     if (!SymTable) {
       DRI.d.a = 0;
       DRI.d.b = 0;
       return DRI;
     }
     assert(SymTable->sh_type == ELF::SHT_SYMTAB ||
            SymTable->sh_type == ELF::SHT_DYNSYM);
 
-    uintptr_t SHT = reinterpret_cast<uintptr_t>((*EF.sections()).begin());
+    auto SectionsOrErr = EF.sections();
+    if (!SectionsOrErr) {
+      DRI.d.a = 0;
+      DRI.d.b = 0;
+      return DRI;
+    }
+    uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
     unsigned SymTableIndex =
         (reinterpret_cast<uintptr_t>(SymTable) - SHT) / sizeof(Elf_Shdr);
 
     DRI.d.a = SymTableIndex;
     DRI.d.b = SymbolNum;
     return DRI;
   }
 

 public:
   ELFObjectFile(MemoryBufferRef Object, std::error_code &EC);
 
   const Elf_Rel *getRel(DataRefImpl Rel) const;
   const Elf_Rela *getRela(DataRefImpl Rela) const;
 
   const Elf_Sym *getSymbol(DataRefImpl Sym) const {
     auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
-    if (std::error_code EC = Ret.getError())
-      report_fatal_error(EC.message());
+    if (!Ret)
+      report_fatal_error(errorToErrorCode(Ret.takeError()).message());
     return *Ret;
   }
 
   const Elf_Shdr *getSection(DataRefImpl Sec) const {
     return reinterpret_cast<const Elf_Shdr *>(Sec.p);
   }
 
   basic_symbol_iterator symbol_begin_impl() const override;

 template <class ELFT>
 void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
   ++Sym.d.b;
 }
 
 template <class ELFT>
 Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
   const Elf_Sym *ESym = getSymbol(Sym);
-  const Elf_Shdr *SymTableSec = *EF.getSection(Sym.d.a);
-  const Elf_Shdr *StringTableSec = *EF.getSection(SymTableSec->sh_link);
-  StringRef SymTable = *EF.getStringTable(StringTableSec);
-  return ESym->getName(SymTable);
+  auto SymTabOrErr = EF.getSection(Sym.d.a);
+  if (!SymTabOrErr)
+    return SymTabOrErr.takeError();
+  const Elf_Shdr *SymTableSec = *SymTabOrErr;
+  auto StrTabOrErr = EF.getSection(SymTableSec->sh_link);
+  if (!StrTabOrErr)
+    return StrTabOrErr.takeError();
+  const Elf_Shdr *StringTableSec = *StrTabOrErr;
+  auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
+  if (!SymStrTabOrErr)
+    return SymStrTabOrErr.takeError();
+  return ESym->getName(*SymStrTabOrErr);
 }
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSectionFlags(DataRefImpl Sec) const {
   return getSection(Sec)->sh_flags;
 }
 
 template <class ELFT>
ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
   switch (ESym->st_shndx) {
   case ELF::SHN_COMMON:
   case ELF::SHN_UNDEF:
   case ELF::SHN_ABS:
     return Result;
   }
 
   const Elf_Ehdr *Header = EF.getHeader();
-  const Elf_Shdr *SymTab = *EF.getSection(Symb.d.a);
+  auto SymTabOrErr = EF.getSection(Symb.d.a);
+  if (!SymTabOrErr)
+    return SymTabOrErr.takeError();
+  const Elf_Shdr *SymTab = *SymTabOrErr;
 
   if (Header->e_type == ELF::ET_REL) {
-    ErrorOr<const Elf_Shdr *> SectionOrErr =
-        EF.getSection(ESym, SymTab, ShndxTable);
-    if (std::error_code EC = SectionOrErr.getError())
-      return errorCodeToError(EC);
+    auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
+    if (!SectionOrErr)
+      return SectionOrErr.takeError();
     const Elf_Shdr *Section = *SectionOrErr;
     if (Section)
       Result += Section->sh_addr;
   }
 
   return Result;
 }
 
if (ESym->getBinding() != ELF::STB_LOCAL)
     Result |= SymbolRef::SF_Global;
 
   if (ESym->getBinding() == ELF::STB_WEAK)
     Result |= SymbolRef::SF_Weak;
 
   if (ESym->st_shndx == ELF::SHN_ABS)
     Result |= SymbolRef::SF_Absolute;
 
-  if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION ||
-      ESym == (*EF.symbols(DotSymtabSec)).begin() ||
-      ESym == (*EF.symbols(DotDynSymSec)).begin())
+  if (ESym->getType() == ELF::STT_FILE || ESym->getType() == ELF::STT_SECTION)
+    Result |= SymbolRef::SF_FormatSpecific;
+
+  auto DotSymtabSecSyms = EF.symbols(DotSymtabSec);
+  if (DotSymtabSecSyms && ESym == (*DotSymtabSecSyms).begin())
+    Result |= SymbolRef::SF_FormatSpecific;
+  auto DotDynSymSecSyms = EF.symbols(DotDynSymSec);
+  if (DotDynSymSecSyms && ESym == (*DotDynSymSecSyms).begin())
     Result |= SymbolRef::SF_FormatSpecific;
 
   if (EF.getHeader()->e_machine == ELF::EM_ARM) {
     if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
       StringRef Name = *NameOrErr;
       if (Name.startswith("$d") || Name.startswith("$t") ||
           Name.startswith("$a"))
         Result |= SymbolRef::SF_FormatSpecific;
uint32_t ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
 
   return Result;
 }
 
 template <class ELFT>
 Expected<section_iterator>
 ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
                                       const Elf_Shdr *SymTab) const {
-  ErrorOr<const Elf_Shdr *> ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
-  if (std::error_code EC = ESecOrErr.getError())
-    return errorCodeToError(EC);
+  auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
+  if (!ESecOrErr)
+    return ESecOrErr.takeError();
 
   const Elf_Shdr *ESec = *ESecOrErr;
   if (!ESec)
     return section_end();
 
   DataRefImpl Sec;
   Sec.p = reinterpret_cast<intptr_t>(ESec);
   return section_iterator(SectionRef(Sec, this));
 }
 
 template <class ELFT>
 Expected<section_iterator>
 ELFObjectFile<ELFT>::getSymbolSection(DataRefImpl Symb) const {
   const Elf_Sym *Sym = getSymbol(Symb);
-  const Elf_Shdr *SymTab = *EF.getSection(Symb.d.a);
+  auto SymTabOrErr = EF.getSection(Symb.d.a);
+  if (!SymTabOrErr)
+    return SymTabOrErr.takeError();
+  const Elf_Shdr *SymTab = *SymTabOrErr;
   return getSymbolSection(Sym, SymTab);
 }
 
 template <class ELFT>
 void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
   const Elf_Shdr *ESec = getSection(Sec);
   Sec = toDRI(++ESec);
 }
 
 template <class ELFT>
 std::error_code ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec,
                                                     StringRef &Result) const {
-  ErrorOr<StringRef> Name = EF.getSectionName(&*getSection(Sec));
+  auto Name = EF.getSectionName(&*getSection(Sec));
   if (!Name)
-    return Name.getError();
+    return errorToErrorCode(Name.takeError());
   Result = *Name;
   return std::error_code();
 }
 
 template <class ELFT>
 uint64_t ELFObjectFile<ELFT>::getSectionAddress(DataRefImpl Sec) const {
   return getSection(Sec)->sh_addr;
 }

 bool ELFObjectFile<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
   return getSection(Sec)->sh_type == ELF::SHT_NOBITS;
 }
 
 template <class ELFT>
 relocation_iterator
 ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
   DataRefImpl RelData;
-  uintptr_t SHT = reinterpret_cast<uintptr_t>((*EF.sections()).begin());
+  auto SectionsOrErr = EF.sections();
+  if (!SectionsOrErr)
+    return relocation_iterator(RelocationRef());
+  uintptr_t SHT = reinterpret_cast<uintptr_t>((*SectionsOrErr).begin());
   RelData.d.a = (Sec.p - SHT) / EF.getHeader()->e_shentsize;
   RelData.d.b = 0;
   return relocation_iterator(RelocationRef(RelData, this));
 }
 
 template <class ELFT>
 relocation_iterator
 ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
   const Elf_Shdr *S = reinterpret_cast<const Elf_Shdr *>(Sec.p);
   relocation_iterator Begin = section_rel_begin(Sec);
   if (S->sh_type != ELF::SHT_RELA && S->sh_type != ELF::SHT_REL)
     return Begin;
   DataRefImpl RelData = Begin->getRawDataRefImpl();
   const Elf_Shdr *RelSec = getRelSection(RelData);
 
   // Error check sh_link here so that getRelocationSymbol can just use it.
-  ErrorOr<const Elf_Shdr *> SymSecOrErr = EF.getSection(RelSec->sh_link);
-  if (std::error_code EC = SymSecOrErr.getError())
-    report_fatal_error(EC.message());
+  auto SymSecOrErr = EF.getSection(RelSec->sh_link);
+  if (!SymSecOrErr)
+    report_fatal_error(errorToErrorCode(SymSecOrErr.takeError()).message());
 
   RelData.d.b += S->sh_size / S->sh_entsize;
   return relocation_iterator(RelocationRef(RelData, this));
 }
 
 template <class ELFT>
 section_iterator
 ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
   if (EF.getHeader()->e_type != ELF::ET_REL)
     return section_end();
 
   const Elf_Shdr *EShdr = getSection(Sec);
   uintX_t Type = EShdr->sh_type;
   if (Type != ELF::SHT_REL && Type != ELF::SHT_RELA)
     return section_end();
 
-  ErrorOr<const Elf_Shdr *> R = EF.getSection(EShdr->sh_info);
-  if (std::error_code EC = R.getError())
-    report_fatal_error(EC.message());
+  auto R = EF.getSection(EShdr->sh_info);
+  if (!R)
+    report_fatal_error(errorToErrorCode(R.takeError()).message());
   return section_iterator(SectionRef(toDRI(*R), this));
 }
 
 // Relocations
 template <class ELFT>
 void ELFObjectFile<ELFT>::moveRelocationNext(DataRefImpl &Rel) const {
   ++Rel.d.b;
 }
ELFObjectFile<ELFT>::getRelocationAddend(DataRefImpl Rel) const {
   return (int64_t)getRela(Rel)->r_addend;
 }
 
 template <class ELFT>
 const typename ELFObjectFile<ELFT>::Elf_Rel *
 ELFObjectFile<ELFT>::getRel(DataRefImpl Rel) const {
   assert(getRelSection(Rel)->sh_type == ELF::SHT_REL);
   auto Ret = EF.template getEntry<Elf_Rel>(Rel.d.a, Rel.d.b);
-  if (std::error_code EC = Ret.getError())
-    report_fatal_error(EC.message());
+  if (!Ret)
+    report_fatal_error(errorToErrorCode(Ret.takeError()).message());
   return *Ret;
 }
 
 template <class ELFT>
 const typename ELFObjectFile<ELFT>::Elf_Rela *
 ELFObjectFile<ELFT>::getRela(DataRefImpl Rela) const {
   assert(getRelSection(Rela)->sh_type == ELF::SHT_RELA);
   auto Ret = EF.template getEntry<Elf_Rela>(Rela.d.a, Rela.d.b);
-  if (std::error_code EC = Ret.getError())
-    report_fatal_error(EC.message());
+  if (!Ret)
+    report_fatal_error(errorToErrorCode(Ret.takeError()).message());
   return *Ret;
 }
 
 template <class ELFT>
 ELFObjectFile<ELFT>::ELFObjectFile(MemoryBufferRef Object, std::error_code &EC)
     : ELFObjectFileBase(
           getELFType(ELFT::TargetEndianness == support::little, ELFT::Is64Bits),
           Object),
       EF(Data.getBuffer()) {
   auto SectionsOrErr = EF.sections();
-  if ((EC = SectionsOrErr.getError()))
+  if (!SectionsOrErr) {
+    EC = errorToErrorCode(SectionsOrErr.takeError());
     return;
+  }
   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     switch (Sec.sh_type) {
     case ELF::SHT_DYNSYM: {
       if (DotDynSymSec) {
         // More than one .dynsym!
         EC = object_error::parse_failed;
         return;
       }
       DotDynSymSec = &Sec;
       break;
     }
     case ELF::SHT_SYMTAB: {
       if (DotSymtabSec) {
         // More than one .dynsym!
         EC = object_error::parse_failed;
         return;
       }
       DotSymtabSec = &Sec;
       break;
     }
     case ELF::SHT_SYMTAB_SHNDX: {
-      ErrorOr<ArrayRef<Elf_Word>> TableOrErr = EF.getSHNDXTable(Sec);
-      if ((EC = TableOrErr.getError()))
+      auto TableOrErr = EF.getSHNDXTable(Sec);
+      if (!TableOrErr) {
+        EC = errorToErrorCode(TableOrErr.takeError());
         return;
+      }
       ShndxTable = *TableOrErr;
       break;
     }
     }
   }
 }
 
 template <class ELFT>

 elf_symbol_iterator ELFObjectFile<ELFT>::dynamic_symbol_end() const {
   const Elf_Shdr *SymTab = DotDynSymSec;
   DataRefImpl Sym = toDRI(SymTab, SymTab->sh_size / sizeof(Elf_Sym));
   return basic_symbol_iterator(SymbolRef(Sym, this));
 }
 
 template <class ELFT>
 section_iterator ELFObjectFile<ELFT>::section_begin() const {
-  return section_iterator(SectionRef(toDRI((*EF.sections()).begin()), this));
+  auto SectionsOrErr = EF.sections();
+  if (!SectionsOrErr)
+    return section_iterator(SectionRef());
+  return section_iterator(SectionRef(toDRI((*SectionsOrErr).begin()), this));
 }
 
 template <class ELFT>
 section_iterator ELFObjectFile<ELFT>::section_end() const {
-  return section_iterator(SectionRef(toDRI((*EF.sections()).end()), this));
+  auto SectionsOrErr = EF.sections();
+  if (!SectionsOrErr)
+    return section_iterator(SectionRef());
+  return section_iterator(SectionRef(toDRI((*SectionsOrErr).end()), this));
 }
 
 template <class ELFT>
 uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
   return ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT>

tools/llvm-objdump/ELFDump.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 
 template <class ELFT> void printProgramHeaders(const ELFFile<ELFT> *o) {
   typedef ELFFile<ELFT> ELFO;
   outs() << "Program Header:\n";
   auto ProgramHeaderOrError = o->program_headers();
-  if (std::error_code EC = ProgramHeaderOrError.getError())
-    report_fatal_error(EC.message());
+  if (!ProgramHeaderOrError)
+    report_fatal_error(
+        errorToErrorCode(ProgramHeaderOrError.takeError()).message());
   for (const typename ELFO::Elf_Phdr &Phdr : *ProgramHeaderOrError) {
     switch (Phdr.p_type) {
     case ELF::PT_LOAD:
       outs() << "    LOAD ";
       break;
     case ELF::PT_GNU_STACK:
       outs() << "   STACK ";
       break;

tools/llvm-objdump/llvm-objdump.cpp

   DataRefImpl Rel = RelRef.getRawDataRefImpl();
 
   typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename ELFObjectFile<ELFT>::Elf_Rela Elf_Rela;
 
   const ELFFile<ELFT> &EF = *Obj->getELFFile();
 
-  ErrorOr<const Elf_Shdr *> SecOrErr = EF.getSection(Rel.d.a);
-  if (std::error_code EC = SecOrErr.getError())
-    return EC;
+  auto SecOrErr = EF.getSection(Rel.d.a);
+  if (!SecOrErr)
+    return errorToErrorCode(SecOrErr.takeError());
   const Elf_Shdr *Sec = *SecOrErr;
-  ErrorOr<const Elf_Shdr *> SymTabOrErr = EF.getSection(Sec->sh_link);
-  if (std::error_code EC = SymTabOrErr.getError())
-    return EC;
+  auto SymTabOrErr = EF.getSection(Sec->sh_link);
+  if (!SymTabOrErr)
+    return errorToErrorCode(SymTabOrErr.takeError());
   const Elf_Shdr *SymTab = *SymTabOrErr;
   assert(SymTab->sh_type == ELF::SHT_SYMTAB ||
          SymTab->sh_type == ELF::SHT_DYNSYM);
-  ErrorOr<const Elf_Shdr *> StrTabSec = EF.getSection(SymTab->sh_link);
-  if (std::error_code EC = StrTabSec.getError())
-    return EC;
-  ErrorOr<StringRef> StrTabOrErr = EF.getStringTable(*StrTabSec);
-  if (std::error_code EC = StrTabOrErr.getError())
-    return EC;
+  auto StrTabSec = EF.getSection(SymTab->sh_link);
+  if (!StrTabSec)
+    return errorToErrorCode(StrTabSec.takeError());
+  auto StrTabOrErr = EF.getStringTable(*StrTabSec);
+  if (!StrTabOrErr)
+    return errorToErrorCode(StrTabOrErr.takeError());
   StringRef StrTab = *StrTabOrErr;
   uint8_t type = RelRef.getType();
   StringRef res;
   int64_t addend = 0;
   switch (Sec->sh_type) {
   default:
     return object_error::parse_failed;
   case ELF::SHT_REL: {

   symbol_iterator SI = RelRef.getSymbol();
   const Elf_Sym *symb = Obj->getSymbol(SI->getRawDataRefImpl());
   StringRef Target;
   if (symb->getType() == ELF::STT_SECTION) {
     Expected<section_iterator> SymSI = SI->getSection();
     if (!SymSI)
       return errorToErrorCode(SymSI.takeError());
     const Elf_Shdr *SymSec = Obj->getSection((*SymSI)->getRawDataRefImpl());
-    ErrorOr<StringRef> SecName = EF.getSectionName(SymSec);
-    if (std::error_code EC = SecName.getError())
-      return EC;
+    auto SecName = EF.getSectionName(SymSec);
+    if (!SecName)
+      return errorToErrorCode(SecName.takeError());
     Target = *SecName;
   } else {
     Expected<StringRef> SymName = symb->getName(StrTab);
     if (!SymName)
       return errorToErrorCode(SymName.takeError());
     Target = *SymName;
   }
   switch (EF.getHeader()->e_machine) {

tools/llvm-readobj/ARMEHABIPrinter.h

 
 template <typename ET>
 const size_t PrinterContext<ET>::IndexTableEntrySize = 8;
 
 template <typename ET>
 ErrorOr<StringRef>
 PrinterContext<ET>::FunctionAtAddress(unsigned Section,
                                       uint64_t Address) const {
-  ErrorOr<StringRef> StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
-  error(StrTableOrErr.getError());
+  auto StrTableOrErr = ELF->getStringTableForSymtab(*Symtab);
+  if (!StrTableOrErr)
+    error(errorToErrorCode(StrTableOrErr.takeError()));
   StringRef StrTable = *StrTableOrErr;
 
   for (const Elf_Sym &Sym : unwrapOrError(ELF->symbols(Symtab)))
     if (Sym.st_shndx == Section && Sym.st_value == Address &&
         Sym.getType() == ELF::STT_FUNC) {
       auto NameOrErr = Sym.getName(StrTable);
       if (!NameOrErr) {
         // TODO: Actually report errors helpfully.
PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
   /// IndexTableOffset.  The symbol is the section symbol for the exception
   /// handling table.  Use this symbol to recover the actual exception handling
   /// table.
 
   for (const Elf_Shdr &Sec : unwrapOrError(ELF->sections())) {
     if (Sec.sh_type != ELF::SHT_REL || Sec.sh_info != IndexSectionIndex)
       continue;
 
-    ErrorOr<const Elf_Shdr *> SymTabOrErr = ELF->getSection(Sec.sh_link);
-    error(SymTabOrErr.getError());
+    auto SymTabOrErr = ELF->getSection(Sec.sh_link);
+    if (!SymTabOrErr)
+      error(SymTabOrErr.takeError());
     const Elf_Shdr *SymTab = *SymTabOrErr;
 
     for (const Elf_Rel &R : unwrapOrError(ELF->rels(&Sec))) {
       if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
         continue;
 
       typename object::ELFFile<ET>::Elf_Rela RelA;
       RelA.r_offset = R.r_offset;
       RelA.r_info = R.r_info;
       RelA.r_addend = 0;
 
       const Elf_Sym *Symbol =
           unwrapOrError(ELF->getRelocationSymbol(&RelA, SymTab));
 
-      ErrorOr<const Elf_Shdr *> Ret =
-          ELF->getSection(Symbol, SymTab, ShndxTable);
-      if (std::error_code EC = Ret.getError())
-        report_fatal_error(EC.message());
+      auto Ret = ELF->getSection(Symbol, SymTab, ShndxTable);
+      if (!Ret)
+        report_fatal_error(errorToErrorCode(Ret.takeError()).message());
       return *Ret;
     }
   }
   return nullptr;
 }
 
 template <typename ET>
 void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
                                              const Elf_Shdr *EHT,
                                              uint64_t TableEntryOffset) const {
-  ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(EHT);
+  Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(EHT);
   if (!Contents)
     return;
 
   /// ARM EHABI Section 6.2 - The generic model
   ///
   /// An exception-handling table entry for the generic model is laid out as:
   ///
   ///  3 3
void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry,
                                       size_t Length, off_t Offset) const {
   ListScope OCC(SW, "Opcodes");
   OpcodeDecoder(OCC.W).Decode(Entry, Offset, Length);
 }
 
 template <typename ET>
 void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
                                          const Elf_Shdr *IT) const {
-  ErrorOr<ArrayRef<uint8_t> > Contents = ELF->getSectionContents(IT);
+  Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(IT);
   if (!Contents)
     return;
 
   /// ARM EHABI Section 5 - Index Table Entries
   /// * The first word contains a PREL31 offset to the start of a function with
   ///   bit 31 clear
   /// * The second word contains one of:
   ///   - The PREL31 offset of the start of the table entry for the function,
if (Word1 & 0x80000000) {
       unsigned PersonalityIndex = (Word1 & 0x0f000000) >> 24;
       SW.printNumber("PersonalityIndex", PersonalityIndex);
 
       PrintOpcodes(Contents->data() + Entry * IndexTableEntrySize + 4, 3, 1);
     } else {
       const Elf_Shdr *EHT =
         FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
 
-      if (ErrorOr<StringRef> Name = ELF->getSectionName(EHT))
+      if (auto Name = ELF->getSectionName(EHT))
         SW.printString("ExceptionHandlingTable", *Name);
 
       uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr);
       SW.printHex("TableEntryOffset", TableEntryOffset);
 
       PrintExceptionTable(IT, EHT, TableEntryOffset);
     }
   }
 }
 
 template <typename ET>
 void PrinterContext<ET>::PrintUnwindInformation() const {
   DictScope UI(SW, "UnwindInformation");
 
   int SectionIndex = 0;
   for (const Elf_Shdr &Sec : unwrapOrError(ELF->sections())) {
     if (Sec.sh_type == ELF::SHT_ARM_EXIDX) {
       DictScope UIT(SW, "UnwindIndexTable");
 
       SW.printNumber("SectionIndex", SectionIndex);
-      if (ErrorOr<StringRef> SectionName = ELF->getSectionName(&Sec))
+      if (auto SectionName = ELF->getSectionName(&Sec))
         SW.printString("SectionName", *SectionName);
       SW.printHex("SectionOffset", Sec.sh_offset);
 
       PrintIndexTable(SectionIndex, &Sec);
     }
     ++SectionIndex;
   }
 }
 }
 }
 }
 
 #endif
 

tools/obj2yaml/elf2yaml.cpp

ErrorOr<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
   Y->Header.Machine = Obj.getHeader()->e_machine;
   Y->Header.Flags = Obj.getHeader()->e_flags;
   Y->Header.Entry = Obj.getHeader()->e_entry;
 
   const Elf_Shdr *Symtab = nullptr;
 
   // Dump sections
   auto SectionsOrErr = Obj.sections();
-  if (std::error_code EC = SectionsOrErr.getError())
-    return EC;
+  if (!SectionsOrErr)
+    return errorToErrorCode(SectionsOrErr.takeError());
   for (const Elf_Shdr &Sec : *SectionsOrErr) {
     switch (Sec.sh_type) {
     case ELF::SHT_NULL:
     case ELF::SHT_DYNSYM:
     case ELF::SHT_STRTAB:
       // Do not dump these sections.
       break;
     case ELF::SHT_SYMTAB:
       Symtab = &Sec;
       break;
     case ELF::SHT_SYMTAB_SHNDX: {
-      ErrorOr<ArrayRef<Elf_Word>> TableOrErr = Obj.getSHNDXTable(Sec);
-      if (std::error_code EC = TableOrErr.getError())
-        return EC;
+      auto TableOrErr = Obj.getSHNDXTable(Sec);
+      if (!TableOrErr)
+        return errorToErrorCode(TableOrErr.takeError());
       ShndxTable = *TableOrErr;
       break;
     }
     case ELF::SHT_RELA: {
       ErrorOr<ELFYAML::RelocationSection *> S = dumpRelaSection(&Sec);
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
default: {
       if (std::error_code EC = S.getError())
         return EC;
       Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
     }
     }
   }
 
   // Dump symbols
-  ErrorOr<StringRef> StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
-  if (std::error_code EC = StrTableOrErr.getError())
-    return EC;
+  auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
+  if (!StrTableOrErr)
+    return errorToErrorCode(StrTableOrErr.takeError());
   StringRef StrTable = *StrTableOrErr;
 
   bool IsFirstSym = true;
   auto SymtabOrErr = Obj.symbols(Symtab);
-  if (std::error_code EC = SymtabOrErr.getError())
-    return EC;
+  if (!SymtabOrErr)
+    return errorToErrorCode(SymtabOrErr.takeError());
   for (const Elf_Sym &Sym : *SymtabOrErr) {
     if (IsFirstSym) {
       IsFirstSym = false;
       continue;
     }
 
     ELFYAML::Symbol S;
     if (std::error_code EC =
ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
   S.Size = Sym->st_size;
   S.Other = Sym->st_other;
 
   Expected<StringRef> SymbolNameOrErr = Sym->getName(StrTable);
   if (!SymbolNameOrErr)
     return errorToErrorCode(SymbolNameOrErr.takeError());
   S.Name = SymbolNameOrErr.get();
 
-  ErrorOr<const Elf_Shdr *> ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
-  if (std::error_code EC = ShdrOrErr.getError())
-    return EC;
+  auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
+  if (!ShdrOrErr)
+    return errorToErrorCode(ShdrOrErr.takeError());
   const Elf_Shdr *Shdr = *ShdrOrErr;
   if (!Shdr)
     return obj2yaml_error::success;
 
-  ErrorOr<StringRef> NameOrErr = Obj.getSectionName(Shdr);
-  if (std::error_code EC = NameOrErr.getError())
-    return EC;
+  auto NameOrErr = Obj.getSectionName(Shdr);
+  if (!NameOrErr)
+    return errorToErrorCode(NameOrErr.takeError());
   S.Section = NameOrErr.get();
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 template <class RelT>
 std::error_code ELFDumper<ELFT>::dumpRelocation(const RelT *Rel,
                                                 const Elf_Shdr *SymTab,
                                                 ELFYAML::Relocation &R) {
   R.Type = Rel->getType(Obj.isMips64EL());
   R.Offset = Rel->r_offset;
   R.Addend = 0;
 
   auto SymOrErr = Obj.getRelocationSymbol(Rel, SymTab);
-  if (std::error_code EC = SymOrErr.getError())
-    return EC;
+  if (!SymOrErr)
+    return errorToErrorCode(SymOrErr.takeError());
   const Elf_Sym *Sym = *SymOrErr;
-  ErrorOr<const Elf_Shdr *> StrTabSec = Obj.getSection(SymTab->sh_link);
-  if (std::error_code EC = StrTabSec.getError())
-    return EC;
-  ErrorOr<StringRef> StrTabOrErr = Obj.getStringTable(*StrTabSec);
-  if (std::error_code EC = StrTabOrErr.getError())
-    return EC;
+  auto StrTabSec = Obj.getSection(SymTab->sh_link);
+  if (!StrTabSec)
+    return errorToErrorCode(StrTabSec.takeError());
+  auto StrTabOrErr = Obj.getStringTable(*StrTabSec);
+  if (!StrTabOrErr)
+    return errorToErrorCode(StrTabOrErr.takeError());
   StringRef StrTab = *StrTabOrErr;
 
   Expected<StringRef> NameOrErr = Sym->getName(StrTab);
   if (!NameOrErr)
     return errorToErrorCode(NameOrErr.takeError());
   R.Symbol = NameOrErr.get();
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 std::error_code ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
                                                    ELFYAML::Section &S) {
   S.Type = Shdr->sh_type;
   S.Flags = Shdr->sh_flags;
   S.Address = Shdr->sh_addr;
   S.AddressAlign = Shdr->sh_addralign;
 
-  ErrorOr<StringRef> NameOrErr = Obj.getSectionName(Shdr);
-  if (std::error_code EC = NameOrErr.getError())
-    return EC;
+  auto NameOrErr = Obj.getSectionName(Shdr);
+  if (!NameOrErr)
+    return errorToErrorCode(NameOrErr.takeError());
   S.Name = NameOrErr.get();
 
   if (Shdr->sh_link != ELF::SHN_UNDEF) {
-    ErrorOr<const Elf_Shdr *> LinkSection = Obj.getSection(Shdr->sh_link);
-    if (std::error_code EC = LinkSection.getError())
-      return EC;
+    auto LinkSection = Obj.getSection(Shdr->sh_link);
+    if (LinkSection.takeError())
+      return errorToErrorCode(LinkSection.takeError());
     NameOrErr = Obj.getSectionName(*LinkSection);
-    if (std::error_code EC = NameOrErr.getError())
-      return EC;
+    if (!NameOrErr)
+      return errorToErrorCode(NameOrErr.takeError());
     S.Link = NameOrErr.get();
   }
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 std::error_code
 ELFDumper<ELFT>::dumpCommonRelocationSection(const Elf_Shdr *Shdr,
                                              ELFYAML::RelocationSection &S) {
   if (std::error_code EC = dumpCommonSection(Shdr, S))
     return EC;
 
-  ErrorOr<const Elf_Shdr *> InfoSection = Obj.getSection(Shdr->sh_info);
-  if (std::error_code EC = InfoSection.getError())
-    return EC;
+  auto InfoSection = Obj.getSection(Shdr->sh_info);
+  if (!InfoSection)
+    return errorToErrorCode(InfoSection.takeError());
 
-  ErrorOr<StringRef> NameOrErr = Obj.getSectionName(*InfoSection);
-  if (std::error_code EC = NameOrErr.getError())
-    return EC;
+  auto NameOrErr = Obj.getSectionName(*InfoSection);
+  if (!NameOrErr)
+    return errorToErrorCode(NameOrErr.takeError());
   S.Info = NameOrErr.get();
 
   return obj2yaml_error::success;
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::RelocationSection *>
 ELFDumper<ELFT>::dumpRelSection(const Elf_Shdr *Shdr) {
   assert(Shdr->sh_type == ELF::SHT_REL && "Section type is not SHT_REL");
   auto S = make_unique<ELFYAML::RelocationSection>();
 
   if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S))
     return EC;
 
-  ErrorOr<const Elf_Shdr *> SymTabOrErr = Obj.getSection(Shdr->sh_link);
-  if (std::error_code EC = SymTabOrErr.getError())
-    return EC;
+  auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
+  if (!SymTabOrErr)
+    return errorToErrorCode(SymTabOrErr.takeError());
   const Elf_Shdr *SymTab = *SymTabOrErr;
 
   auto Rels = Obj.rels(Shdr);
-  if (std::error_code EC = Rels.getError())
-    return EC;
+  if (!Rels)
+    return errorToErrorCode(Rels.takeError());
   for (const Elf_Rel &Rel : *Rels) {
     ELFYAML::Relocation R;
     if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
       return EC;
     S->Relocations.push_back(R);
   }
 
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::RelocationSection *>
 ELFDumper<ELFT>::dumpRelaSection(const Elf_Shdr *Shdr) {
   assert(Shdr->sh_type == ELF::SHT_RELA && "Section type is not SHT_RELA");
   auto S = make_unique<ELFYAML::RelocationSection>();
 
   if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S))
     return EC;
 
-  ErrorOr<const Elf_Shdr *> SymTabOrErr = Obj.getSection(Shdr->sh_link);
-  if (std::error_code EC = SymTabOrErr.getError())
-    return EC;
+  auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
+  if (!SymTabOrErr)
+    return errorToErrorCode(SymTabOrErr.takeError());
   const Elf_Shdr *SymTab = *SymTabOrErr;
 
   auto Rels = Obj.relas(Shdr);
-  if (std::error_code EC = Rels.getError())
-    return EC;
+  if (!Rels)
+    return errorToErrorCode(Rels.takeError());
   for (const Elf_Rela &Rel : *Rels) {
     ELFYAML::Relocation R;
     if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
       return EC;
     R.Addend = Rel.r_addend;
     S->Relocations.push_back(R);
   }
 
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::RawContentSection *>
 ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::RawContentSection>();
 
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
 
-  ErrorOr<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
-  if (std::error_code EC = ContentOrErr.getError())
-    return EC;
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return errorToErrorCode(ContentOrErr.takeError());
   S->Content = yaml::BinaryRef(ContentOrErr.get());
   S->Size = S->Content.binary_size();
 
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::NoBitsSection *>

 
 template <class ELFT>
 ErrorOr<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
   auto S = make_unique<ELFYAML::Group>();
 
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
   // Get sh_info which is the signature.
-  ErrorOr<const Elf_Shdr *> SymtabOrErr = Obj.getSection(Shdr->sh_link);
-  if (std::error_code EC = SymtabOrErr.getError())
-    return EC;
+  auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
+  if (!SymtabOrErr)
+    return errorToErrorCode(SymtabOrErr.takeError());
   const Elf_Shdr *Symtab = *SymtabOrErr;
-  ErrorOr<const Elf_Sym *> SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info);
-  if (std::error_code EC = SymOrErr.getError())
-    return EC;
+  auto SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info);
+  if (!SymOrErr)
+    return errorToErrorCode(SymOrErr.takeError());
   const Elf_Sym *symbol = *SymOrErr;
-  ErrorOr<StringRef> StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
-  if (std::error_code EC = StrTabOrErr.getError())
-    return EC;
+  auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
+  if (!StrTabOrErr)
+    return errorToErrorCode(StrTabOrErr.takeError());
   StringRef StrTab = *StrTabOrErr;
   auto sectionContents = Obj.getSectionContents(Shdr);
-  if (std::error_code ec = sectionContents.getError())
-    return ec;
+  if (!sectionContents)
+    return errorToErrorCode(sectionContents.takeError());
   Expected<StringRef> symbolName = symbol->getName(StrTab);
   if (!symbolName)
     return errorToErrorCode(symbolName.takeError());
   S->Info = *symbolName;
   const Elf_Word *groupMembers =
       reinterpret_cast<const Elf_Word *>(sectionContents->data());
   const long count = (Shdr->sh_size) / sizeof(Elf_Word);
   ELFYAML::SectionOrType s;
   for (int i = 0; i < count; i++) {
     if (groupMembers[i] == llvm::ELF::GRP_COMDAT) {
       s.sectionNameOrType = "GRP_COMDAT";
     } else {
-      ErrorOr<const Elf_Shdr *> sHdr = Obj.getSection(groupMembers[i]);
-      if (std::error_code EC = sHdr.getError())
-        return EC;
-      ErrorOr<StringRef> sectionName = Obj.getSectionName(*sHdr);
-      if (std::error_code ec = sectionName.getError())
-        return ec;
+      auto sHdr = Obj.getSection(groupMembers[i]);
+      if (!sHdr)
+        return errorToErrorCode(sHdr.takeError());
+      auto sectionName = Obj.getSectionName(*sHdr);
+      if (!sectionName)
+        return errorToErrorCode(sectionName.takeError());
       s.sectionNameOrType = *sectionName;
     }
     S->Members.push_back(s);
   }
   return S.release();
 }
 
 template <class ELFT>
 ErrorOr<ELFYAML::MipsABIFlags *>
 ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
   assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS &&
          "Section type is not SHT_MIPS_ABIFLAGS");
   auto S = make_unique<ELFYAML::MipsABIFlags>();
   if (std::error_code EC = dumpCommonSection(Shdr, *S))
     return EC;
 
-  ErrorOr<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
-  if (std::error_code EC = ContentOrErr.getError())
-    return EC;
+  auto ContentOrErr = Obj.getSectionContents(Shdr);
+  if (!ContentOrErr)
+    return errorToErrorCode(ContentOrErr.takeError());
 
   auto *Flags = reinterpret_cast<const object::Elf_Mips_ABIFlags<ELFT> *>(
       ContentOrErr.get().data());
   S->Version = Flags->version;
   S->ISALevel = Flags->isa_level;
   S->ISARevision = Flags->isa_rev;
   S->GPRSize = Flags->gpr_size;
   S->CPR1Size = Flags->cpr1_size;