Index: include/llvm/Object/ELF.h =================================================================== --- include/llvm/Object/ELF.h +++ include/llvm/Object/ELF.h @@ -354,22 +354,19 @@ return getSection(Index); } -template -inline Expected -getSymbol(typename ELFT::SymRange Symbols, uint32_t Index) { - if (Index >= Symbols.size()) - // TODO: this error is untested. - return createError("invalid symbol index"); - return &Symbols[Index]; -} - template Expected ELFFile::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const { - auto SymtabOrErr = symbols(Sec); - if (!SymtabOrErr) - return SymtabOrErr.takeError(); - return object::getSymbol(*SymtabOrErr, Index); + auto SymsOrErr = symbols(Sec); + if (!SymsOrErr) + return SymsOrErr.takeError(); + + Elf_Sym_Range Symbols = *SymsOrErr; + if (Index >= Symbols.size()) + return createError("unable to get symbol from section " + + getSecIndexForError(this, Sec) + + ": invalid symbol index (" + Twine(Index) + ")"); + return &Symbols[Index]; } template Index: test/tools/obj2yaml/section-group.test =================================================================== --- test/tools/obj2yaml/section-group.test +++ test/tools/obj2yaml/section-group.test @@ -1,6 +1,6 @@ ## Checks that the tool is able to read section groups from ELF. -# RUN: yaml2obj %s > %t1.o +# RUN: yaml2obj --docnum=1 %s > %t1.o # RUN: llvm-readobj --elf-section-groups %t1.o | FileCheck %s -check-prefix=OBJ # RUN: obj2yaml %t1.o | FileCheck %s --check-prefix YAML @@ -46,3 +46,25 @@ - Name: signature Type: STT_OBJECT Section: .rodata + +## Check obj2yaml report an error when sh_info field of +## group section contains invalid (too large) signature symbol index. + +# RUN: yaml2obj --docnum=2 %s > %t2.o +# RUN: not obj2yaml %t2.o 2>&1 | FileCheck %s --check-prefix ERR + +--- !ELF +FileHeader: + Class: ELFCLASS64 + Data: ELFDATA2LSB + Type: ET_REL + Machine: EM_X86_64 +Sections: + - Name: .group + Type: SHT_GROUP + Link: .symtab + Info: 0xFF + Members: + - SectionOrType: GRP_COMDAT + +# ERR: Error reading file: {{.*}}2.o: unable to get symbol from section [index 2]: invalid symbol index (255) Index: test/tools/obj2yaml/special-symbol-indices.yaml =================================================================== --- test/tools/obj2yaml/special-symbol-indices.yaml +++ test/tools/obj2yaml/special-symbol-indices.yaml @@ -51,4 +51,4 @@ ## shn_xindex.o contains a symbol with st_shndx == SHN_XINDEX. ## We do not support it at this moment. # RUN: not obj2yaml %S/Inputs/shn_xindex.o 2>&1 | FileCheck %s --check-prefix=ERR -# ERR: Error reading file: {{.*}}shn_xindex.o: Feature not yet implemented. +# ERR: Error reading file: {{.*}}shn_xindex.o: SHN_XINDEX symbols are not supported Index: tools/obj2yaml/elf2yaml.cpp =================================================================== --- tools/obj2yaml/elf2yaml.cpp +++ tools/obj2yaml/elf2yaml.cpp @@ -44,31 +44,31 @@ const object::ELFFile &Obj; ArrayRef ShndxTable; - std::error_code dumpSymbols(const Elf_Shdr *Symtab, - std::vector &Symbols); - std::error_code dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab, - StringRef StrTable, ELFYAML::Symbol &S); - std::error_code dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S); - std::error_code dumpCommonRelocationSection(const Elf_Shdr *Shdr, - ELFYAML::RelocationSection &S); + Error dumpSymbols(const Elf_Shdr *Symtab, + std::vector &Symbols); + Error dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab, + StringRef StrTable, ELFYAML::Symbol &S); + Error dumpCommonSection(const Elf_Shdr *Shdr, ELFYAML::Section &S); + Error dumpCommonRelocationSection(const Elf_Shdr *Shdr, + ELFYAML::RelocationSection &S); template - std::error_code dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab, - ELFYAML::Relocation &R); - - ErrorOr dumpDynamicSection(const Elf_Shdr *Shdr); - ErrorOr dumpRelocSection(const Elf_Shdr *Shdr); - ErrorOr + Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab, + ELFYAML::Relocation &R); + + Expected dumpDynamicSection(const Elf_Shdr *Shdr); + Expected dumpRelocSection(const Elf_Shdr *Shdr); + Expected dumpContentSection(const Elf_Shdr *Shdr); - ErrorOr dumpNoBitsSection(const Elf_Shdr *Shdr); - ErrorOr dumpVerdefSection(const Elf_Shdr *Shdr); - ErrorOr dumpSymverSection(const Elf_Shdr *Shdr); - ErrorOr dumpVerneedSection(const Elf_Shdr *Shdr); - ErrorOr dumpGroup(const Elf_Shdr *Shdr); - ErrorOr dumpMipsABIFlags(const Elf_Shdr *Shdr); + Expected dumpNoBitsSection(const Elf_Shdr *Shdr); + Expected dumpVerdefSection(const Elf_Shdr *Shdr); + Expected dumpSymverSection(const Elf_Shdr *Shdr); + Expected dumpVerneedSection(const Elf_Shdr *Shdr); + Expected dumpGroup(const Elf_Shdr *Shdr); + Expected dumpMipsABIFlags(const Elf_Shdr *Shdr); public: ELFDumper(const object::ELFFile &O); - ErrorOr dump(); + Expected dump(); }; } @@ -134,7 +134,7 @@ return Name; } -template ErrorOr ELFDumper::dump() { +template Expected ELFDumper::dump() { auto Y = make_unique(); // Dump header. We do not dump SHEntSize, SHOffset, SHNum and SHStrNdx field. @@ -152,7 +152,7 @@ // Dump sections auto SectionsOrErr = Obj.sections(); if (!SectionsOrErr) - return errorToErrorCode(SectionsOrErr.takeError()); + return SectionsOrErr.takeError(); Sections = *SectionsOrErr; SectionNames.resize(Sections.size()); @@ -160,20 +160,20 @@ // to access the deduplicated symbol names that we also create here. for (const Elf_Shdr &Sec : Sections) { if (Sec.sh_type == ELF::SHT_SYMTAB) - if (auto EC = dumpSymbols(&Sec, Y->Symbols)) - return EC; + if (Error E = dumpSymbols(&Sec, Y->Symbols)) + return std::move(E); if (Sec.sh_type == ELF::SHT_DYNSYM) - if (auto EC = dumpSymbols(&Sec, Y->DynamicSymbols)) - return EC; + if (Error E = dumpSymbols(&Sec, Y->DynamicSymbols)) + return std::move(E); } for (const Elf_Shdr &Sec : Sections) { switch (Sec.sh_type) { case ELF::SHT_DYNAMIC: { - ErrorOr S = dumpDynamicSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpDynamicSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_NULL: @@ -185,65 +185,66 @@ case ELF::SHT_SYMTAB_SHNDX: { auto TableOrErr = Obj.getSHNDXTable(Sec); if (!TableOrErr) - return errorToErrorCode(TableOrErr.takeError()); + return TableOrErr.takeError(); ShndxTable = *TableOrErr; break; } case ELF::SHT_REL: case ELF::SHT_RELA: { - ErrorOr S = dumpRelocSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpRelocSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_GROUP: { - ErrorOr G = dumpGroup(&Sec); - if (std::error_code EC = G.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(G.get())); + Expected GroupOrErr = dumpGroup(&Sec); + if (!GroupOrErr) + return GroupOrErr.takeError(); + Y->Sections.emplace_back(*GroupOrErr); break; } case ELF::SHT_MIPS_ABIFLAGS: { - ErrorOr G = dumpMipsABIFlags(&Sec); - if (std::error_code EC = G.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(G.get())); + Expected SecOrErr = dumpMipsABIFlags(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_NOBITS: { - ErrorOr S = dumpNoBitsSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpNoBitsSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_GNU_verdef: { - ErrorOr S = dumpVerdefSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpVerdefSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_GNU_versym: { - ErrorOr S = dumpSymverSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpSymverSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } case ELF::SHT_GNU_verneed: { - ErrorOr S = dumpVerneedSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = dumpVerneedSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); break; } default: { - ErrorOr S = dumpContentSection(&Sec); - if (std::error_code EC = S.getError()) - return EC; - Y->Sections.push_back(std::unique_ptr(S.get())); + Expected SecOrErr = + dumpContentSection(&Sec); + if (!SecOrErr) + return SecOrErr.takeError(); + Y->Sections.emplace_back(*SecOrErr); } } } @@ -252,20 +253,19 @@ } template -std::error_code -ELFDumper::dumpSymbols(const Elf_Shdr *Symtab, +Error ELFDumper::dumpSymbols(const Elf_Shdr *Symtab, std::vector &Symbols) { if (!Symtab) - return std::error_code(); + return Error::success(); auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab); if (!StrTableOrErr) - return errorToErrorCode(StrTableOrErr.takeError()); + return StrTableOrErr.takeError(); StringRef StrTable = *StrTableOrErr; auto SymtabOrErr = Obj.symbols(Symtab); if (!SymtabOrErr) - return errorToErrorCode(SymtabOrErr.takeError()); + return SymtabOrErr.takeError(); if (Symtab->sh_type == ELF::SHT_SYMTAB) { SymTable = *SymtabOrErr; @@ -279,13 +279,12 @@ Symbols.push_back(S); } - return std::error_code(); + return Error::success(); } template -std::error_code -ELFDumper::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab, - StringRef StrTable, ELFYAML::Symbol &S) { +Error ELFDumper::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab, + StringRef StrTable, ELFYAML::Symbol &S) { S.Type = Sym->getType(); S.Value = Sym->st_value; S.Size = Sym->st_size; @@ -295,56 +294,56 @@ Expected SymbolNameOrErr = getUniquedSymbolName(Sym, StrTable, SymTab); if (!SymbolNameOrErr) - return errorToErrorCode(SymbolNameOrErr.takeError()); + return SymbolNameOrErr.takeError(); S.Name = SymbolNameOrErr.get(); if (Sym->st_shndx >= ELF::SHN_LORESERVE) { if (Sym->st_shndx == ELF::SHN_XINDEX) - return obj2yaml_error::not_implemented; + return createStringError(obj2yaml_error::not_implemented, + "SHN_XINDEX symbols are not supported"); S.Index = (ELFYAML::ELF_SHN)Sym->st_shndx; - return obj2yaml_error::success; + return Error::success(); } auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable); if (!ShdrOrErr) - return errorToErrorCode(ShdrOrErr.takeError()); + return ShdrOrErr.takeError(); const Elf_Shdr *Shdr = *ShdrOrErr; if (!Shdr) - return obj2yaml_error::success; + return Error::success(); auto NameOrErr = getUniquedSectionName(Shdr); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); S.Section = NameOrErr.get(); - return obj2yaml_error::success; + return Error::success(); } template template -std::error_code ELFDumper::dumpRelocation(const RelT *Rel, - const Elf_Shdr *SymTab, - ELFYAML::Relocation &R) { +Error ELFDumper::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 (!SymOrErr) - return errorToErrorCode(SymOrErr.takeError()); + return SymOrErr.takeError(); const Elf_Sym *Sym = *SymOrErr; auto StrTabSec = Obj.getSection(SymTab->sh_link); if (!StrTabSec) - return errorToErrorCode(StrTabSec.takeError()); + return StrTabSec.takeError(); auto StrTabOrErr = Obj.getStringTable(*StrTabSec); if (!StrTabOrErr) - return errorToErrorCode(StrTabOrErr.takeError()); + return StrTabOrErr.takeError(); StringRef StrTab = *StrTabOrErr; if (Sym) { Expected NameOrErr = getUniquedSymbolName(Sym, StrTab, SymTab); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); R.Symbol = NameOrErr.get(); } else { // We have some edge cases of relocations without a symbol associated, @@ -354,12 +353,12 @@ R.Symbol = ""; } - return obj2yaml_error::success; + return Error::success(); } template -std::error_code ELFDumper::dumpCommonSection(const Elf_Shdr *Shdr, - ELFYAML::Section &S) { +Error ELFDumper::dumpCommonSection(const Elf_Shdr *Shdr, + ELFYAML::Section &S) { // Dump fields. We do not dump the ShOffset field. When not explicitly // set, the value is set by yaml2obj automatically. S.Type = Shdr->sh_type; @@ -372,51 +371,50 @@ auto NameOrErr = getUniquedSectionName(Shdr); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); S.Name = NameOrErr.get(); if (Shdr->sh_link != ELF::SHN_UNDEF) { auto LinkSection = Obj.getSection(Shdr->sh_link); if (LinkSection.takeError()) - return errorToErrorCode(LinkSection.takeError()); + return LinkSection.takeError(); NameOrErr = getUniquedSectionName(*LinkSection); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); S.Link = NameOrErr.get(); } - return obj2yaml_error::success; + return Error::success(); } template -std::error_code -ELFDumper::dumpCommonRelocationSection(const Elf_Shdr *Shdr, - ELFYAML::RelocationSection &S) { - if (std::error_code EC = dumpCommonSection(Shdr, S)) - return EC; +Error ELFDumper::dumpCommonRelocationSection( + const Elf_Shdr *Shdr, ELFYAML::RelocationSection &S) { + if (Error E = dumpCommonSection(Shdr, S)) + return std::move(E); auto InfoSection = Obj.getSection(Shdr->sh_info); if (!InfoSection) - return errorToErrorCode(InfoSection.takeError()); + return InfoSection.takeError(); auto NameOrErr = getUniquedSectionName(*InfoSection); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); S.RelocatableSec = NameOrErr.get(); - return obj2yaml_error::success; + return Error::success(); } template -ErrorOr +Expected ELFDumper::dumpDynamicSection(const Elf_Shdr *Shdr) { auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); auto DynTagsOrErr = Obj.template getSectionContentsAsArray(Shdr); if (!DynTagsOrErr) - return errorToErrorCode(DynTagsOrErr.takeError()); + return DynTagsOrErr.takeError(); for (const Elf_Dyn &Dyn : *DynTagsOrErr) S->Entries.push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()}); @@ -425,35 +423,35 @@ } template -ErrorOr +Expected ELFDumper::dumpRelocSection(const Elf_Shdr *Shdr) { auto S = make_unique(); - if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S)) - return EC; + if (auto E = dumpCommonRelocationSection(Shdr, *S)) + return std::move(E); auto SymTabOrErr = Obj.getSection(Shdr->sh_link); if (!SymTabOrErr) - return errorToErrorCode(SymTabOrErr.takeError()); + return SymTabOrErr.takeError(); const Elf_Shdr *SymTab = *SymTabOrErr; if (Shdr->sh_type == ELF::SHT_REL) { auto Rels = Obj.rels(Shdr); if (!Rels) - return errorToErrorCode(Rels.takeError()); + return Rels.takeError(); for (const Elf_Rel &Rel : *Rels) { ELFYAML::Relocation R; - if (std::error_code EC = dumpRelocation(&Rel, SymTab, R)) - return EC; + if (Error E = dumpRelocation(&Rel, SymTab, R)) + return std::move(E); S->Relocations.push_back(R); } } else { auto Rels = Obj.relas(Shdr); if (!Rels) - return errorToErrorCode(Rels.takeError()); + return Rels.takeError(); for (const Elf_Rela &Rel : *Rels) { ELFYAML::Relocation R; - if (std::error_code EC = dumpRelocation(&Rel, SymTab, R)) - return EC; + if (Error E = dumpRelocation(&Rel, SymTab, R)) + return std::move(E); R.Addend = Rel.r_addend; S->Relocations.push_back(R); } @@ -463,16 +461,15 @@ } template -ErrorOr +Expected ELFDumper::dumpContentSection(const Elf_Shdr *Shdr) { auto S = make_unique(); - - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); auto ContentOrErr = Obj.getSectionContents(Shdr); if (!ContentOrErr) - return errorToErrorCode(ContentOrErr.takeError()); + return ContentOrErr.takeError(); ArrayRef Content = *ContentOrErr; if (!Content.empty()) S->Content = yaml::BinaryRef(Content); @@ -482,40 +479,39 @@ } template -ErrorOr +Expected ELFDumper::dumpNoBitsSection(const Elf_Shdr *Shdr) { auto S = make_unique(); - - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); S->Size = Shdr->sh_size; return S.release(); } template -ErrorOr +Expected ELFDumper::dumpVerdefSection(const Elf_Shdr *Shdr) { typedef typename ELFT::Verdef Elf_Verdef; typedef typename ELFT::Verdaux Elf_Verdaux; auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); S->Info = Shdr->sh_info; auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link); if (!StringTableShdrOrErr) - return errorToErrorCode(StringTableShdrOrErr.takeError()); + return StringTableShdrOrErr.takeError(); auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr); if (!StringTableOrErr) - return errorToErrorCode(StringTableOrErr.takeError()); + return StringTableOrErr.takeError(); auto Contents = Obj.getSectionContents(Shdr); if (!Contents) - return errorToErrorCode(Contents.takeError()); + return Contents.takeError(); llvm::ArrayRef Data = *Contents; const uint8_t *Buf = Data.data(); @@ -544,17 +540,17 @@ } template -ErrorOr +Expected ELFDumper::dumpSymverSection(const Elf_Shdr *Shdr) { typedef typename ELFT::Half Elf_Half; auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); auto VersionsOrErr = Obj.template getSectionContentsAsArray(Shdr); if (!VersionsOrErr) - return errorToErrorCode(VersionsOrErr.takeError()); + return VersionsOrErr.takeError(); for (const Elf_Half &E : *VersionsOrErr) S->Entries.push_back(E); @@ -562,28 +558,28 @@ } template -ErrorOr +Expected ELFDumper::dumpVerneedSection(const Elf_Shdr *Shdr) { typedef typename ELFT::Verneed Elf_Verneed; typedef typename ELFT::Vernaux Elf_Vernaux; auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); S->Info = Shdr->sh_info; auto Contents = Obj.getSectionContents(Shdr); if (!Contents) - return errorToErrorCode(Contents.takeError()); + return Contents.takeError(); auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link); if (!StringTableShdrOrErr) - return errorToErrorCode(StringTableShdrOrErr.takeError()); + return StringTableShdrOrErr.takeError(); auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr); if (!StringTableOrErr) - return errorToErrorCode(StringTableOrErr.takeError()); + return StringTableOrErr.takeError(); llvm::ArrayRef Data = *Contents; const uint8_t *Buf = Data.data(); @@ -619,32 +615,32 @@ } template -ErrorOr ELFDumper::dumpGroup(const Elf_Shdr *Shdr) { +Expected ELFDumper::dumpGroup(const Elf_Shdr *Shdr) { auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); auto SymtabOrErr = Obj.getSection(Shdr->sh_link); if (!SymtabOrErr) - return errorToErrorCode(SymtabOrErr.takeError()); + return SymtabOrErr.takeError(); // Get symbol with index sh_info which name is the signature of the group. const Elf_Shdr *Symtab = *SymtabOrErr; auto SymOrErr = Obj.getSymbol(Symtab, Shdr->sh_info); if (!SymOrErr) - return errorToErrorCode(SymOrErr.takeError()); + return SymOrErr.takeError(); auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab); if (!StrTabOrErr) - return errorToErrorCode(StrTabOrErr.takeError()); + return StrTabOrErr.takeError(); Expected SymbolName = getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab); if (!SymbolName) - return errorToErrorCode(SymbolName.takeError()); + return SymbolName.takeError(); S->Signature = *SymbolName; auto MembersOrErr = Obj.template getSectionContentsAsArray(Shdr); if (!MembersOrErr) - return errorToErrorCode(MembersOrErr.takeError()); + return MembersOrErr.takeError(); for (Elf_Word Member : *MembersOrErr) { if (Member == llvm::ELF::GRP_COMDAT) { @@ -654,27 +650,27 @@ auto SHdrOrErr = Obj.getSection(Member); if (!SHdrOrErr) - return errorToErrorCode(SHdrOrErr.takeError()); + return SHdrOrErr.takeError(); auto NameOrErr = getUniquedSectionName(*SHdrOrErr); if (!NameOrErr) - return errorToErrorCode(NameOrErr.takeError()); + return NameOrErr.takeError(); S->Members.push_back({*NameOrErr}); } return S.release(); } template -ErrorOr +Expected ELFDumper::dumpMipsABIFlags(const Elf_Shdr *Shdr) { assert(Shdr->sh_type == ELF::SHT_MIPS_ABIFLAGS && "Section type is not SHT_MIPS_ABIFLAGS"); auto S = make_unique(); - if (std::error_code EC = dumpCommonSection(Shdr, *S)) - return EC; + if (Error E = dumpCommonSection(Shdr, *S)) + return std::move(E); auto ContentOrErr = Obj.getSectionContents(Shdr); if (!ContentOrErr) - return errorToErrorCode(ContentOrErr.takeError()); + return ContentOrErr.takeError(); auto *Flags = reinterpret_cast *>( ContentOrErr.get().data()); @@ -693,21 +689,20 @@ } template -static std::error_code elf2yaml(raw_ostream &Out, - const object::ELFFile &Obj) { +static Error elf2yaml(raw_ostream &Out, const object::ELFFile &Obj) { ELFDumper Dumper(Obj); - ErrorOr YAMLOrErr = Dumper.dump(); - if (std::error_code EC = YAMLOrErr.getError()) - return EC; + Expected YAMLOrErr = Dumper.dump(); + if (!YAMLOrErr) + return YAMLOrErr.takeError(); std::unique_ptr YAML(YAMLOrErr.get()); yaml::Output Yout(Out); Yout << *YAML; - return std::error_code(); + return Error::success(); } -std::error_code elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) { +Error elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) { if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); @@ -720,5 +715,5 @@ if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); - return obj2yaml_error::unsupported_obj_file_format; + llvm_unreachable("unknown ELF file format"); } Index: tools/obj2yaml/obj2yaml.h =================================================================== --- tools/obj2yaml/obj2yaml.h +++ tools/obj2yaml/obj2yaml.h @@ -21,7 +21,7 @@ std::error_code coff2yaml(llvm::raw_ostream &Out, const llvm::object::COFFObjectFile &Obj); -std::error_code elf2yaml(llvm::raw_ostream &Out, +llvm::Error elf2yaml(llvm::raw_ostream &Out, const llvm::object::ObjectFile &Obj); std::error_code macho2yaml(llvm::raw_ostream &Out, const llvm::object::Binary &Obj); Index: tools/obj2yaml/obj2yaml.cpp =================================================================== --- tools/obj2yaml/obj2yaml.cpp +++ tools/obj2yaml/obj2yaml.cpp @@ -17,19 +17,20 @@ using namespace llvm; using namespace llvm::object; -static std::error_code dumpObject(const ObjectFile &Obj) { +static Error dumpObject(const ObjectFile &Obj) { if (Obj.isCOFF()) - return coff2yaml(outs(), cast(Obj)); + return errorCodeToError(coff2yaml(outs(), cast(Obj))); if (Obj.isXCOFF()) - return xcoff2yaml(outs(), cast(Obj)); + return errorCodeToError(xcoff2yaml(outs(), cast(Obj))); if (Obj.isELF()) return elf2yaml(outs(), Obj); + if (Obj.isWasm()) - return wasm2yaml(outs(), cast(Obj)); + return errorCodeToError(wasm2yaml(outs(), cast(Obj))); - return obj2yaml_error::unsupported_obj_file_format; + return errorCodeToError(obj2yaml_error::unsupported_obj_file_format); } static Error dumpInput(StringRef File) { @@ -44,7 +45,7 @@ return errorCodeToError(macho2yaml(outs(), Binary)); // TODO: If this is an archive, then burst it and dump each entry if (ObjectFile *Obj = dyn_cast(&Binary)) - return errorCodeToError(dumpObject(*Obj)); + return dumpObject(*Obj); if (MinidumpFile *Minidump = dyn_cast(&Binary)) return minidump2yaml(outs(), *Minidump);