//===------ utils/elf2yaml.cpp - obj2yaml conversion tool -------*- C++ -*-===// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// #include "Error.h" #include "obj2yaml.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Object/ELFObjectFile.h" #include "llvm/Object/ELFYAML.h" #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/YAMLTraits.h" using namespace llvm; namespace { template class ELFDumper { typedef object::Elf_Sym_Impl Elf_Sym; typedef typename object::ELFFile::Elf_Shdr Elf_Shdr; typedef typename object::ELFFile::Elf_Sym_Iter Elf_Sym_Iter; typedef typename object::ELFFile::Elf_Word Elf_Word; const object::ELFFile &Obj; std::error_code dumpSymbol(Elf_Sym_Iter Sym, 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 std::error_code dumpRelocation(const Elf_Shdr *Shdr, const RelT *Rel, ELFYAML::Relocation &R); ErrorOr dumpRelSection(const Elf_Shdr *Shdr); ErrorOr dumpRelaSection(const Elf_Shdr *Shdr); ErrorOr dumpContentSection(const Elf_Shdr *Shdr); ErrorOr dumpGroup(const Elf_Shdr *Shdr); ErrorOr dumpMipsABIFlags(const Elf_Shdr *Shdr); public: ELFDumper(const object::ELFFile &O); ErrorOr dump(); }; } template ELFDumper::ELFDumper(const object::ELFFile &O) : Obj(O) {} template ErrorOr ELFDumper::dump() { auto Y = make_unique(); // Dump header Y->Header.Class = ELFYAML::ELF_ELFCLASS(Obj.getHeader()->getFileClass()); Y->Header.Data = ELFYAML::ELF_ELFDATA(Obj.getHeader()->getDataEncoding()); Y->Header.OSABI = Obj.getHeader()->e_ident[ELF::EI_OSABI]; Y->Header.Type = Obj.getHeader()->e_type; Y->Header.Machine = Obj.getHeader()->e_machine; Y->Header.Flags = Obj.getHeader()->e_flags; Y->Header.Entry = Obj.getHeader()->e_entry; // Dump sections for (const Elf_Shdr &Sec : Obj.sections()) { switch (Sec.sh_type) { case ELF::SHT_NULL: case ELF::SHT_SYMTAB: case ELF::SHT_DYNSYM: case ELF::SHT_STRTAB: // Do not dump these sections. break; case ELF::SHT_RELA: { ErrorOr S = dumpRelaSection(&Sec); if (std::error_code EC = S.getError()) return EC; Y->Sections.push_back(std::unique_ptr(S.get())); break; } case ELF::SHT_REL: { ErrorOr S = dumpRelSection(&Sec); if (std::error_code EC = S.getError()) return EC; Y->Sections.push_back(std::unique_ptr(S.get())); 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())); 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())); break; } default: { ErrorOr S = dumpContentSection(&Sec); if (std::error_code EC = S.getError()) return EC; Y->Sections.push_back(std::unique_ptr(S.get())); } } } // Dump symbols bool IsFirstSym = true; for (auto SI = Obj.begin_symbols(), SE = Obj.end_symbols(); SI != SE; ++SI) { if (IsFirstSym) { IsFirstSym = false; continue; } ELFYAML::Symbol S; if (std::error_code EC = ELFDumper::dumpSymbol(SI, S)) return EC; switch (SI->getBinding()) { case ELF::STB_LOCAL: Y->Symbols.Local.push_back(S); break; case ELF::STB_GLOBAL: Y->Symbols.Global.push_back(S); break; case ELF::STB_WEAK: Y->Symbols.Weak.push_back(S); break; default: llvm_unreachable("Unknown ELF symbol binding"); } } return Y.release(); } template std::error_code ELFDumper::dumpSymbol(Elf_Sym_Iter Sym, ELFYAML::Symbol &S) { S.Type = Sym->getType(); S.Value = Sym->st_value; S.Size = Sym->st_size; S.Other = Sym->st_other; ErrorOr NameOrErr = Obj.getSymbolName(Sym); if (std::error_code EC = NameOrErr.getError()) return EC; S.Name = NameOrErr.get(); const Elf_Shdr *Shdr = Obj.getSection(&*Sym); if (!Shdr) return obj2yaml_error::success; NameOrErr = Obj.getSectionName(Shdr); if (std::error_code EC = NameOrErr.getError()) return EC; S.Section = NameOrErr.get(); return obj2yaml_error::success; } template template std::error_code ELFDumper::dumpRelocation(const Elf_Shdr *Shdr, const RelT *Rel, ELFYAML::Relocation &R) { R.Type = Rel->getType(Obj.isMips64EL()); R.Offset = Rel->r_offset; R.Addend = 0; auto NamePair = Obj.getRelocationSymbol(Shdr, Rel); if (!NamePair.first) return obj2yaml_error::success; ErrorOr NameOrErr = Obj.getSymbolName(NamePair.first, NamePair.second); if (std::error_code EC = NameOrErr.getError()) return EC; R.Symbol = NameOrErr.get(); return obj2yaml_error::success; } template std::error_code ELFDumper::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 NameOrErr = Obj.getSectionName(Shdr); if (std::error_code EC = NameOrErr.getError()) return EC; S.Name = NameOrErr.get(); if (Shdr->sh_link != ELF::SHN_UNDEF) { if (const Elf_Shdr *LinkSection = Obj.getSection(Shdr->sh_link)) { NameOrErr = Obj.getSectionName(LinkSection); if (std::error_code EC = NameOrErr.getError()) return EC; S.Link = NameOrErr.get(); } } return obj2yaml_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; if (const Elf_Shdr *InfoSection = Obj.getSection(Shdr->sh_info)) { ErrorOr NameOrErr = Obj.getSectionName(InfoSection); if (std::error_code EC = NameOrErr.getError()) return EC; S.Info = NameOrErr.get(); } return obj2yaml_error::success; } template ErrorOr ELFDumper::dumpRelSection(const Elf_Shdr *Shdr) { assert(Shdr->sh_type == ELF::SHT_REL && "Section type is not SHT_REL"); auto S = make_unique(); if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S)) return EC; for (auto RI = Obj.begin_rel(Shdr), RE = Obj.end_rel(Shdr); RI != RE; ++RI) { ELFYAML::Relocation R; if (std::error_code EC = dumpRelocation(Shdr, &*RI, R)) return EC; S->Relocations.push_back(R); } return S.release(); } template ErrorOr ELFDumper::dumpRelaSection(const Elf_Shdr *Shdr) { assert(Shdr->sh_type == ELF::SHT_RELA && "Section type is not SHT_RELA"); auto S = make_unique(); if (std::error_code EC = dumpCommonRelocationSection(Shdr, *S)) return EC; for (auto RI = Obj.begin_rela(Shdr), RE = Obj.end_rela(Shdr); RI != RE; ++RI) { ELFYAML::Relocation R; if (std::error_code EC = dumpRelocation(Shdr, &*RI, R)) return EC; R.Addend = RI->r_addend; S->Relocations.push_back(R); } return S.release(); } template ErrorOr ELFDumper::dumpContentSection(const Elf_Shdr *Shdr) { auto S = make_unique(); if (std::error_code EC = dumpCommonSection(Shdr, *S)) return EC; ErrorOr> ContentOrErr = Obj.getSectionContents(Shdr); if (std::error_code EC = ContentOrErr.getError()) return EC; S->Content = yaml::BinaryRef(ContentOrErr.get()); S->Size = S->Content.binary_size(); return S.release(); } template ErrorOr ELFDumper::dumpGroup(const Elf_Shdr *Shdr) { auto S = make_unique(); if (std::error_code EC = dumpCommonSection(Shdr, *S)) return EC; // Get sh_info which is the signature. const Elf_Sym *symbol = Obj.getSymbol(Shdr->sh_info); const Elf_Shdr *symtab = Obj.getSection(Shdr->sh_link); auto sectionContents = Obj.getSectionContents(Shdr); if (std::error_code ec = sectionContents.getError()) return ec; ErrorOr symbolName = Obj.getSymbolName(symtab, symbol); if (std::error_code EC = symbolName.getError()) return EC; S->Info = *symbolName; const Elf_Word *groupMembers = reinterpret_cast(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 { const Elf_Shdr *sHdr = Obj.getSection(groupMembers[i]); ErrorOr sectionName = Obj.getSectionName(sHdr); if (std::error_code ec = sectionName.getError()) return ec; s.sectionNameOrType = *sectionName; } S->Members.push_back(s); } return S.release(); } template ErrorOr 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; ErrorOr> ContentOrErr = Obj.getSectionContents(Shdr); if (std::error_code EC = ContentOrErr.getError()) return EC; auto *Flags = reinterpret_cast *>( 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; S->CPR2Size = Flags->cpr2_size; S->FpABI = Flags->fp_abi; S->ISAExtension = Flags->isa_ext; S->ASEs = Flags->ases; S->Flags1 = Flags->flags1; S->Flags2 = Flags->flags2; return S.release(); } template static std::error_code elf2yaml(raw_ostream &Out, const object::ELFFile &Obj) { ELFDumper Dumper(Obj); ErrorOr YAMLOrErr = Dumper.dump(); if (std::error_code EC = YAMLOrErr.getError()) return EC; std::unique_ptr YAML(YAMLOrErr.get()); yaml::Output Yout(Out); Yout << *YAML; return std::error_code(); } std::error_code elf2yaml(raw_ostream &Out, const object::ObjectFile &Obj) { if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); if (const auto *ELFObj = dyn_cast(&Obj)) return elf2yaml(Out, *ELFObj->getELFFile()); return obj2yaml_error::unsupported_obj_file_format; }