summaryrefslogtreecommitdiffstats
path: root/llvm
diff options
context:
space:
mode:
Diffstat (limited to 'llvm')
-rw-r--r--llvm/include/llvm/Object/ELF.h23
-rw-r--r--llvm/test/tools/obj2yaml/section-group.test24
-rw-r--r--llvm/test/tools/obj2yaml/special-symbol-indices.yaml2
-rw-r--r--llvm/tools/obj2yaml/elf2yaml.cpp319
-rw-r--r--llvm/tools/obj2yaml/obj2yaml.cpp13
-rw-r--r--llvm/tools/obj2yaml/obj2yaml.h2
6 files changed, 184 insertions, 199 deletions
diff --git a/llvm/include/llvm/Object/ELF.h b/llvm/include/llvm/Object/ELF.h
index 7bc6dc4620c..8fe9f2919c5 100644
--- a/llvm/include/llvm/Object/ELF.h
+++ b/llvm/include/llvm/Object/ELF.h
@@ -355,21 +355,24 @@ ELFFile<ELFT>::getSection(const Elf_Sym *Sym, Elf_Sym_Range Symbols,
}
template <class ELFT>
-Expected<const typename ELFT::Sym *>
-ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
- auto SymsOrErr = symbols(Sec);
- if (!SymsOrErr)
- return SymsOrErr.takeError();
-
- Elf_Sym_Range Symbols = *SymsOrErr;
+inline Expected<const typename ELFT::Sym *>
+getSymbol(typename ELFT::SymRange Symbols, uint32_t Index) {
if (Index >= Symbols.size())
- return createError("unable to get symbol from section " +
- getSecIndexForError(this, Sec) +
- ": invalid symbol index (" + Twine(Index) + ")");
+ // TODO: this error is untested.
+ return createError("invalid symbol index");
return &Symbols[Index];
}
template <class ELFT>
+Expected<const typename ELFT::Sym *>
+ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
+ auto SymtabOrErr = symbols(Sec);
+ if (!SymtabOrErr)
+ return SymtabOrErr.takeError();
+ return object::getSymbol<ELFT>(*SymtabOrErr, Index);
+}
+
+template <class ELFT>
template <typename T>
Expected<ArrayRef<T>>
ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
diff --git a/llvm/test/tools/obj2yaml/section-group.test b/llvm/test/tools/obj2yaml/section-group.test
index cd520cb1b36..78af00cd138 100644
--- a/llvm/test/tools/obj2yaml/section-group.test
+++ b/llvm/test/tools/obj2yaml/section-group.test
@@ -1,6 +1,6 @@
## Checks that the tool is able to read section groups from ELF.
-# RUN: yaml2obj --docnum=1 %s > %t1.o
+# RUN: yaml2obj %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,25 +46,3 @@ Symbols:
- 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)
diff --git a/llvm/test/tools/obj2yaml/special-symbol-indices.yaml b/llvm/test/tools/obj2yaml/special-symbol-indices.yaml
index fcc2a705f9c..25550c944f3 100644
--- a/llvm/test/tools/obj2yaml/special-symbol-indices.yaml
+++ b/llvm/test/tools/obj2yaml/special-symbol-indices.yaml
@@ -51,4 +51,4 @@ Symbols:
## 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: SHN_XINDEX symbols are not supported
+# ERR: Error reading file: {{.*}}shn_xindex.o: Feature not yet implemented.
diff --git a/llvm/tools/obj2yaml/elf2yaml.cpp b/llvm/tools/obj2yaml/elf2yaml.cpp
index bd27c103403..7404bae2a08 100644
--- a/llvm/tools/obj2yaml/elf2yaml.cpp
+++ b/llvm/tools/obj2yaml/elf2yaml.cpp
@@ -44,31 +44,31 @@ class ELFDumper {
const object::ELFFile<ELFT> &Obj;
ArrayRef<Elf_Word> ShndxTable;
- Error dumpSymbols(const Elf_Shdr *Symtab,
- std::vector<ELFYAML::Symbol> &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);
+ std::error_code dumpSymbols(const Elf_Shdr *Symtab,
+ std::vector<ELFYAML::Symbol> &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);
template <class RelT>
- Error dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
- ELFYAML::Relocation &R);
-
- Expected<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::RawContentSection *>
+ std::error_code dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
+ ELFYAML::Relocation &R);
+
+ ErrorOr<ELFYAML::DynamicSection *> dumpDynamicSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::RelocationSection *> dumpRelocSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::RawContentSection *>
dumpContentSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
- Expected<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
- Expected<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::NoBitsSection *> dumpNoBitsSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::VerdefSection *> dumpVerdefSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::SymverSection *> dumpSymverSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::VerneedSection *> dumpVerneedSection(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::Group *> dumpGroup(const Elf_Shdr *Shdr);
+ ErrorOr<ELFYAML::MipsABIFlags *> dumpMipsABIFlags(const Elf_Shdr *Shdr);
public:
ELFDumper(const object::ELFFile<ELFT> &O);
- Expected<ELFYAML::Object *> dump();
+ ErrorOr<ELFYAML::Object *> dump();
};
}
@@ -134,7 +134,7 @@ ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
return Name;
}
-template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
+template <class ELFT> ErrorOr<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
auto Y = make_unique<ELFYAML::Object>();
// Dump header. We do not dump SHEntSize, SHOffset, SHNum and SHStrNdx field.
@@ -152,7 +152,7 @@ template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
// Dump sections
auto SectionsOrErr = Obj.sections();
if (!SectionsOrErr)
- return SectionsOrErr.takeError();
+ return errorToErrorCode(SectionsOrErr.takeError());
Sections = *SectionsOrErr;
SectionNames.resize(Sections.size());
@@ -160,20 +160,20 @@ template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
// 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 (Error E = dumpSymbols(&Sec, Y->Symbols))
- return std::move(E);
+ if (auto EC = dumpSymbols(&Sec, Y->Symbols))
+ return EC;
if (Sec.sh_type == ELF::SHT_DYNSYM)
- if (Error E = dumpSymbols(&Sec, Y->DynamicSymbols))
- return std::move(E);
+ if (auto EC = dumpSymbols(&Sec, Y->DynamicSymbols))
+ return EC;
}
for (const Elf_Shdr &Sec : Sections) {
switch (Sec.sh_type) {
case ELF::SHT_DYNAMIC: {
- Expected<ELFYAML::DynamicSection *> SecOrErr = dumpDynamicSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::DynamicSection *> S = dumpDynamicSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
case ELF::SHT_NULL:
@@ -185,66 +185,65 @@ template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
case ELF::SHT_SYMTAB_SHNDX: {
auto TableOrErr = Obj.getSHNDXTable(Sec);
if (!TableOrErr)
- return TableOrErr.takeError();
+ return errorToErrorCode(TableOrErr.takeError());
ShndxTable = *TableOrErr;
break;
}
case ELF::SHT_REL:
case ELF::SHT_RELA: {
- Expected<ELFYAML::RelocationSection *> SecOrErr = dumpRelocSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::RelocationSection *> S = dumpRelocSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
case ELF::SHT_GROUP: {
- Expected<ELFYAML::Group *> GroupOrErr = dumpGroup(&Sec);
- if (!GroupOrErr)
- return GroupOrErr.takeError();
- Y->Sections.emplace_back(*GroupOrErr);
+ ErrorOr<ELFYAML::Group *> G = dumpGroup(&Sec);
+ if (std::error_code EC = G.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(G.get()));
break;
}
case ELF::SHT_MIPS_ABIFLAGS: {
- Expected<ELFYAML::MipsABIFlags *> SecOrErr = dumpMipsABIFlags(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::MipsABIFlags *> G = dumpMipsABIFlags(&Sec);
+ if (std::error_code EC = G.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(G.get()));
break;
}
case ELF::SHT_NOBITS: {
- Expected<ELFYAML::NoBitsSection *> SecOrErr = dumpNoBitsSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::NoBitsSection *> S = dumpNoBitsSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
case ELF::SHT_GNU_verdef: {
- Expected<ELFYAML::VerdefSection *> SecOrErr = dumpVerdefSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::VerdefSection *> S = dumpVerdefSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
case ELF::SHT_GNU_versym: {
- Expected<ELFYAML::SymverSection *> SecOrErr = dumpSymverSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::SymverSection *> S = dumpSymverSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
case ELF::SHT_GNU_verneed: {
- Expected<ELFYAML::VerneedSection *> SecOrErr = dumpVerneedSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::VerneedSection *> S = dumpVerneedSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
break;
}
default: {
- Expected<ELFYAML::RawContentSection *> SecOrErr =
- dumpContentSection(&Sec);
- if (!SecOrErr)
- return SecOrErr.takeError();
- Y->Sections.emplace_back(*SecOrErr);
+ ErrorOr<ELFYAML::RawContentSection *> S = dumpContentSection(&Sec);
+ if (std::error_code EC = S.getError())
+ return EC;
+ Y->Sections.push_back(std::unique_ptr<ELFYAML::Section>(S.get()));
}
}
}
@@ -253,19 +252,20 @@ template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
}
template <class ELFT>
-Error ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
+std::error_code
+ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
std::vector<ELFYAML::Symbol> &Symbols) {
if (!Symtab)
- return Error::success();
+ return std::error_code();
auto StrTableOrErr = Obj.getStringTableForSymtab(*Symtab);
if (!StrTableOrErr)
- return StrTableOrErr.takeError();
+ return errorToErrorCode(StrTableOrErr.takeError());
StringRef StrTable = *StrTableOrErr;
auto SymtabOrErr = Obj.symbols(Symtab);
if (!SymtabOrErr)
- return SymtabOrErr.takeError();
+ return errorToErrorCode(SymtabOrErr.takeError());
if (Symtab->sh_type == ELF::SHT_SYMTAB) {
SymTable = *SymtabOrErr;
@@ -279,12 +279,13 @@ Error ELFDumper<ELFT>::dumpSymbols(const Elf_Shdr *Symtab,
Symbols.push_back(S);
}
- return Error::success();
+ return std::error_code();
}
template <class ELFT>
-Error ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
- StringRef StrTable, ELFYAML::Symbol &S) {
+std::error_code
+ELFDumper<ELFT>::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;
@@ -294,56 +295,56 @@ Error ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
Expected<StringRef> SymbolNameOrErr =
getUniquedSymbolName(Sym, StrTable, SymTab);
if (!SymbolNameOrErr)
- return SymbolNameOrErr.takeError();
+ return errorToErrorCode(SymbolNameOrErr.takeError());
S.Name = SymbolNameOrErr.get();
if (Sym->st_shndx >= ELF::SHN_LORESERVE) {
if (Sym->st_shndx == ELF::SHN_XINDEX)
- return createStringError(obj2yaml_error::not_implemented,
- "SHN_XINDEX symbols are not supported");
+ return obj2yaml_error::not_implemented;
S.Index = (ELFYAML::ELF_SHN)Sym->st_shndx;
- return Error::success();
+ return obj2yaml_error::success;
}
auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
if (!ShdrOrErr)
- return ShdrOrErr.takeError();
+ return errorToErrorCode(ShdrOrErr.takeError());
const Elf_Shdr *Shdr = *ShdrOrErr;
if (!Shdr)
- return Error::success();
+ return obj2yaml_error::success;
auto NameOrErr = getUniquedSectionName(Shdr);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
S.Section = NameOrErr.get();
- return Error::success();
+ return obj2yaml_error::success;
}
template <class ELFT>
template <class RelT>
-Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
- ELFYAML::Relocation &R) {
+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 (!SymOrErr)
- return SymOrErr.takeError();
+ return errorToErrorCode(SymOrErr.takeError());
const Elf_Sym *Sym = *SymOrErr;
auto StrTabSec = Obj.getSection(SymTab->sh_link);
if (!StrTabSec)
- return StrTabSec.takeError();
+ return errorToErrorCode(StrTabSec.takeError());
auto StrTabOrErr = Obj.getStringTable(*StrTabSec);
if (!StrTabOrErr)
- return StrTabOrErr.takeError();
+ return errorToErrorCode(StrTabOrErr.takeError());
StringRef StrTab = *StrTabOrErr;
if (Sym) {
Expected<StringRef> NameOrErr = getUniquedSymbolName(Sym, StrTab, SymTab);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
R.Symbol = NameOrErr.get();
} else {
// We have some edge cases of relocations without a symbol associated,
@@ -353,12 +354,12 @@ Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
R.Symbol = "";
}
- return Error::success();
+ return obj2yaml_error::success;
}
template <class ELFT>
-Error ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
- ELFYAML::Section &S) {
+std::error_code ELFDumper<ELFT>::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;
@@ -371,50 +372,51 @@ Error ELFDumper<ELFT>::dumpCommonSection(const Elf_Shdr *Shdr,
auto NameOrErr = getUniquedSectionName(Shdr);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
S.Name = NameOrErr.get();
if (Shdr->sh_link != ELF::SHN_UNDEF) {
auto LinkSection = Obj.getSection(Shdr->sh_link);
if (LinkSection.takeError())
- return LinkSection.takeError();
+ return errorToErrorCode(LinkSection.takeError());
NameOrErr = getUniquedSectionName(*LinkSection);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
S.Link = NameOrErr.get();
}
- return Error::success();
+ return obj2yaml_error::success;
}
template <class ELFT>
-Error ELFDumper<ELFT>::dumpCommonRelocationSection(
- const Elf_Shdr *Shdr, ELFYAML::RelocationSection &S) {
- if (Error E = dumpCommonSection(Shdr, S))
- return E;
+std::error_code
+ELFDumper<ELFT>::dumpCommonRelocationSection(const Elf_Shdr *Shdr,
+ ELFYAML::RelocationSection &S) {
+ if (std::error_code EC = dumpCommonSection(Shdr, S))
+ return EC;
auto InfoSection = Obj.getSection(Shdr->sh_info);
if (!InfoSection)
- return InfoSection.takeError();
+ return errorToErrorCode(InfoSection.takeError());
auto NameOrErr = getUniquedSectionName(*InfoSection);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
S.RelocatableSec = NameOrErr.get();
- return Error::success();
+ return obj2yaml_error::success;
}
template <class ELFT>
-Expected<ELFYAML::DynamicSection *>
+ErrorOr<ELFYAML::DynamicSection *>
ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
auto S = make_unique<ELFYAML::DynamicSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
if (!DynTagsOrErr)
- return DynTagsOrErr.takeError();
+ return errorToErrorCode(DynTagsOrErr.takeError());
for (const Elf_Dyn &Dyn : *DynTagsOrErr)
S->Entries.push_back({(ELFYAML::ELF_DYNTAG)Dyn.getTag(), Dyn.getVal()});
@@ -423,35 +425,35 @@ ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::RelocationSection *>
+ErrorOr<ELFYAML::RelocationSection *>
ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
auto S = make_unique<ELFYAML::RelocationSection>();
- if (auto E = dumpCommonRelocationSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S))
+ return EC;
auto SymTabOrErr = Obj.getSection(Shdr->sh_link);
if (!SymTabOrErr)
- return SymTabOrErr.takeError();
+ return errorToErrorCode(SymTabOrErr.takeError());
const Elf_Shdr *SymTab = *SymTabOrErr;
if (Shdr->sh_type == ELF::SHT_REL) {
auto Rels = Obj.rels(Shdr);
if (!Rels)
- return Rels.takeError();
+ return errorToErrorCode(Rels.takeError());
for (const Elf_Rel &Rel : *Rels) {
ELFYAML::Relocation R;
- if (Error E = dumpRelocation(&Rel, SymTab, R))
- return std::move(E);
+ if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
+ return EC;
S->Relocations.push_back(R);
}
} else {
auto Rels = Obj.relas(Shdr);
if (!Rels)
- return Rels.takeError();
+ return errorToErrorCode(Rels.takeError());
for (const Elf_Rela &Rel : *Rels) {
ELFYAML::Relocation R;
- if (Error E = dumpRelocation(&Rel, SymTab, R))
- return std::move(E);
+ if (std::error_code EC = dumpRelocation(&Rel, SymTab, R))
+ return EC;
R.Addend = Rel.r_addend;
S->Relocations.push_back(R);
}
@@ -461,15 +463,16 @@ ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::RawContentSection *>
+ErrorOr<ELFYAML::RawContentSection *>
ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
auto S = make_unique<ELFYAML::RawContentSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
auto ContentOrErr = Obj.getSectionContents(Shdr);
if (!ContentOrErr)
- return ContentOrErr.takeError();
+ return errorToErrorCode(ContentOrErr.takeError());
ArrayRef<uint8_t> Content = *ContentOrErr;
if (!Content.empty())
S->Content = yaml::BinaryRef(Content);
@@ -479,39 +482,40 @@ ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::NoBitsSection *>
+ErrorOr<ELFYAML::NoBitsSection *>
ELFDumper<ELFT>::dumpNoBitsSection(const Elf_Shdr *Shdr) {
auto S = make_unique<ELFYAML::NoBitsSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
S->Size = Shdr->sh_size;
return S.release();
}
template <class ELFT>
-Expected<ELFYAML::VerdefSection *>
+ErrorOr<ELFYAML::VerdefSection *>
ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
typedef typename ELFT::Verdef Elf_Verdef;
typedef typename ELFT::Verdaux Elf_Verdaux;
auto S = make_unique<ELFYAML::VerdefSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
S->Info = Shdr->sh_info;
auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
if (!StringTableShdrOrErr)
- return StringTableShdrOrErr.takeError();
+ return errorToErrorCode(StringTableShdrOrErr.takeError());
auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
if (!StringTableOrErr)
- return StringTableOrErr.takeError();
+ return errorToErrorCode(StringTableOrErr.takeError());
auto Contents = Obj.getSectionContents(Shdr);
if (!Contents)
- return Contents.takeError();
+ return errorToErrorCode(Contents.takeError());
llvm::ArrayRef<uint8_t> Data = *Contents;
const uint8_t *Buf = Data.data();
@@ -540,17 +544,17 @@ ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::SymverSection *>
+ErrorOr<ELFYAML::SymverSection *>
ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
typedef typename ELFT::Half Elf_Half;
auto S = make_unique<ELFYAML::SymverSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(Shdr);
if (!VersionsOrErr)
- return VersionsOrErr.takeError();
+ return errorToErrorCode(VersionsOrErr.takeError());
for (const Elf_Half &E : *VersionsOrErr)
S->Entries.push_back(E);
@@ -558,28 +562,28 @@ ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::VerneedSection *>
+ErrorOr<ELFYAML::VerneedSection *>
ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
typedef typename ELFT::Verneed Elf_Verneed;
typedef typename ELFT::Vernaux Elf_Vernaux;
auto S = make_unique<ELFYAML::VerneedSection>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
S->Info = Shdr->sh_info;
auto Contents = Obj.getSectionContents(Shdr);
if (!Contents)
- return Contents.takeError();
+ return errorToErrorCode(Contents.takeError());
auto StringTableShdrOrErr = Obj.getSection(Shdr->sh_link);
if (!StringTableShdrOrErr)
- return StringTableShdrOrErr.takeError();
+ return errorToErrorCode(StringTableShdrOrErr.takeError());
auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
if (!StringTableOrErr)
- return StringTableOrErr.takeError();
+ return errorToErrorCode(StringTableOrErr.takeError());
llvm::ArrayRef<uint8_t> Data = *Contents;
const uint8_t *Buf = Data.data();
@@ -615,32 +619,32 @@ ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
+ErrorOr<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
auto S = make_unique<ELFYAML::Group>();
- if (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
auto SymtabOrErr = Obj.getSection(Shdr->sh_link);
if (!SymtabOrErr)
- return SymtabOrErr.takeError();
+ return errorToErrorCode(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 SymOrErr.takeError();
+ return errorToErrorCode(SymOrErr.takeError());
auto StrTabOrErr = Obj.getStringTableForSymtab(*Symtab);
if (!StrTabOrErr)
- return StrTabOrErr.takeError();
+ return errorToErrorCode(StrTabOrErr.takeError());
Expected<StringRef> SymbolName =
getUniquedSymbolName(*SymOrErr, *StrTabOrErr, Symtab);
if (!SymbolName)
- return SymbolName.takeError();
+ return errorToErrorCode(SymbolName.takeError());
S->Signature = *SymbolName;
auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
if (!MembersOrErr)
- return MembersOrErr.takeError();
+ return errorToErrorCode(MembersOrErr.takeError());
for (Elf_Word Member : *MembersOrErr) {
if (Member == llvm::ELF::GRP_COMDAT) {
@@ -650,27 +654,27 @@ Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
auto SHdrOrErr = Obj.getSection(Member);
if (!SHdrOrErr)
- return SHdrOrErr.takeError();
+ return errorToErrorCode(SHdrOrErr.takeError());
auto NameOrErr = getUniquedSectionName(*SHdrOrErr);
if (!NameOrErr)
- return NameOrErr.takeError();
+ return errorToErrorCode(NameOrErr.takeError());
S->Members.push_back({*NameOrErr});
}
return S.release();
}
template <class ELFT>
-Expected<ELFYAML::MipsABIFlags *>
+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 (Error E = dumpCommonSection(Shdr, *S))
- return std::move(E);
+ if (std::error_code EC = dumpCommonSection(Shdr, *S))
+ return EC;
auto ContentOrErr = Obj.getSectionContents(Shdr);
if (!ContentOrErr)
- return ContentOrErr.takeError();
+ return errorToErrorCode(ContentOrErr.takeError());
auto *Flags = reinterpret_cast<const object::Elf_Mips_ABIFlags<ELFT> *>(
ContentOrErr.get().data());
@@ -689,20 +693,21 @@ ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
}
template <class ELFT>
-static Error elf2yaml(raw_ostream &Out, const object::ELFFile<ELFT> &Obj) {
+static std::error_code elf2yaml(raw_ostream &Out,
+ const object::ELFFile<ELFT> &Obj) {
ELFDumper<ELFT> Dumper(Obj);
- Expected<ELFYAML::Object *> YAMLOrErr = Dumper.dump();
- if (!YAMLOrErr)
- return YAMLOrErr.takeError();
+ ErrorOr<ELFYAML::Object *> YAMLOrErr = Dumper.dump();
+ if (std::error_code EC = YAMLOrErr.getError())
+ return EC;
std::unique_ptr<ELFYAML::Object> YAML(YAMLOrErr.get());
yaml::Output Yout(Out);
Yout << *YAML;
- return Error::success();
+ return std::error_code();
}
-Error elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) {
+std::error_code elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) {
if (const auto *ELFObj = dyn_cast<object::ELF32LEObjectFile>(&Obj))
return elf2yaml(Out, *ELFObj->getELFFile());
@@ -715,5 +720,5 @@ Error elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) {
if (const auto *ELFObj = dyn_cast<object::ELF64BEObjectFile>(&Obj))
return elf2yaml(Out, *ELFObj->getELFFile());
- llvm_unreachable("unknown ELF file format");
+ return obj2yaml_error::unsupported_obj_file_format;
}
diff --git a/llvm/tools/obj2yaml/obj2yaml.cpp b/llvm/tools/obj2yaml/obj2yaml.cpp
index f03b1ef4bad..8622e38319b 100644
--- a/llvm/tools/obj2yaml/obj2yaml.cpp
+++ b/llvm/tools/obj2yaml/obj2yaml.cpp
@@ -17,20 +17,19 @@
using namespace llvm;
using namespace llvm::object;
-static Error dumpObject(const ObjectFile &Obj) {
+static std::error_code dumpObject(const ObjectFile &Obj) {
if (Obj.isCOFF())
- return errorCodeToError(coff2yaml(outs(), cast<COFFObjectFile>(Obj)));
+ return coff2yaml(outs(), cast<COFFObjectFile>(Obj));
if (Obj.isXCOFF())
- return errorCodeToError(xcoff2yaml(outs(), cast<XCOFFObjectFile>(Obj)));
+ return xcoff2yaml(outs(), cast<XCOFFObjectFile>(Obj));
if (Obj.isELF())
return elf2yaml(outs(), Obj);
-
if (Obj.isWasm())
- return errorCodeToError(wasm2yaml(outs(), cast<WasmObjectFile>(Obj)));
+ return wasm2yaml(outs(), cast<WasmObjectFile>(Obj));
- return errorCodeToError(obj2yaml_error::unsupported_obj_file_format);
+ return obj2yaml_error::unsupported_obj_file_format;
}
static Error dumpInput(StringRef File) {
@@ -45,7 +44,7 @@ static Error dumpInput(StringRef File) {
return errorCodeToError(macho2yaml(outs(), Binary));
// TODO: If this is an archive, then burst it and dump each entry
if (ObjectFile *Obj = dyn_cast<ObjectFile>(&Binary))
- return dumpObject(*Obj);
+ return errorCodeToError(dumpObject(*Obj));
if (MinidumpFile *Minidump = dyn_cast<MinidumpFile>(&Binary))
return minidump2yaml(outs(), *Minidump);
diff --git a/llvm/tools/obj2yaml/obj2yaml.h b/llvm/tools/obj2yaml/obj2yaml.h
index 4f4a5330429..b40e2c5c5a6 100644
--- a/llvm/tools/obj2yaml/obj2yaml.h
+++ b/llvm/tools/obj2yaml/obj2yaml.h
@@ -21,7 +21,7 @@
std::error_code coff2yaml(llvm::raw_ostream &Out,
const llvm::object::COFFObjectFile &Obj);
-llvm::Error elf2yaml(llvm::raw_ostream &Out,
+std::error_code elf2yaml(llvm::raw_ostream &Out,
const llvm::object::ObjectFile &Obj);
std::error_code macho2yaml(llvm::raw_ostream &Out,
const llvm::object::Binary &Obj);
OpenPOWER on IntegriCloud