maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[lib/Object] - Refine interface of ELFFile<ELFT>. NFCI. 

`ELFFile<ELFT>` has many methods that take pointers,
though they assume that arguments are never null and
hence could take references instead.

This patch performs such clean-up.

Differential revision: https://reviews.llvm.org/D87385
This commit is contained in:
Georgii Rymar 2020-09-09 17:03:53 +03:00
parent 9b4fa85434
commit 4845531fa8
21 changed files with 378 additions and 379 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lld/ELF/Arch/AMDGPU.cpp
View File

@ -41,7 +41,7 @@ AMDGPU::AMDGPU() {
}
static uint32_t getEFlags(InputFile *file) {
return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader()->e_flags;
return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader().e_flags;
}
uint32_t AMDGPU::calcEFlags() const {

2
lld/ELF/Arch/Hexagon.cpp
View File

@ -66,7 +66,7 @@ uint32_t Hexagon::calcEFlags() const {
// greatest revision in the list of inputs.
uint32_t ret = 0;
for (InputFile *f : objectFiles) {
uint32_t eflags = cast<ObjFile<ELF32LE>>(f)->getObj().getHeader()->e_flags;
uint32_t eflags = cast<ObjFile<ELF32LE>>(f)->getObj().getHeader().e_flags;
if (eflags > ret)
ret = eflags;
}

4
lld/ELF/Arch/Mips.cpp
View File

@ -372,7 +372,7 @@ bool MIPS<ELFT>::needsThunk(RelExpr expr, RelType type, const InputFile *file,
if (!f)
return false;
// If current file has PIC code, LA25 stub is not required.
if (f->getObj().getHeader()->e_flags & EF_MIPS_PIC)
if (f->getObj().getHeader().e_flags & EF_MIPS_PIC)
return false;
auto *d = dyn_cast<Defined>(&s);
// LA25 is required if target file has PIC code
@ -749,7 +749,7 @@ template <class ELFT> bool elf::isMipsPIC(const Defined *sym) {
if (!file)
return false;
return file->getObj().getHeader()->e_flags & EF_MIPS_PIC;
return file->getObj().getHeader().e_flags & EF_MIPS_PIC;
}
template <class ELFT> TargetInfo *elf::getMipsTargetInfo() {

4
lld/ELF/Arch/MipsArchTree.cpp
View File

@ -297,7 +297,7 @@ static uint32_t getArchFlags(ArrayRef<FileFlags> files) {
template <class ELFT> uint32_t elf::calcMipsEFlags() {
std::vector<FileFlags> v;
for (InputFile *f : objectFiles)
v.push_back({f, cast<ObjFile<ELFT>>(f)->getObj().getHeader()->e_flags});
v.push_back({f, cast<ObjFile<ELFT>>(f)->getObj().getHeader().e_flags});
if (v.empty()) {
// If we don't have any input files, we'll have to rely on the information
// we can derive from emulation information, since this at least gets us
@ -363,7 +363,7 @@ uint8_t elf::getMipsFpAbiFlag(uint8_t oldFlag, uint8_t newFlag,
template <class ELFT> static bool isN32Abi(const InputFile *f) {
if (auto *ef = dyn_cast<ELFFileBase>(f))
return ef->template getObj<ELFT>().getHeader()->e_flags & EF_MIPS_ABI2;
return ef->template getObj<ELFT>().getHeader().e_flags & EF_MIPS_ABI2;
return false;
}

4
lld/ELF/Arch/PPC64.cpp
View File

@ -620,8 +620,8 @@ int PPC64::getTlsGdRelaxSkip(RelType type) const {
static uint32_t getEFlags(InputFile *file) {
if (config->ekind == ELF64BEKind)
return cast<ObjFile<ELF64BE>>(file)->getObj().getHeader()->e_flags;
return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader()->e_flags;
return cast<ObjFile<ELF64BE>>(file)->getObj().getHeader().e_flags;
return cast<ObjFile<ELF64LE>>(file)->getObj().getHeader().e_flags;
}
// This file implements v2 ABI. This function makes sure that all

4
lld/ELF/Arch/RISCV.cpp
View File

@ -104,8 +104,8 @@ RISCV::RISCV() {
static uint32_t getEFlags(InputFile *f) {
if (config->is64)
return cast<ObjFile<ELF64LE>>(f)->getObj().getHeader()->e_flags;
return cast<ObjFile<ELF32LE>>(f)->getObj().getHeader()->e_flags;
return cast<ObjFile<ELF64LE>>(f)->getObj().getHeader().e_flags;
return cast<ObjFile<ELF32LE>>(f)->getObj().getHeader().e_flags;
}
uint32_t RISCV::calcEFlags() const {

2
lld/ELF/Driver.cpp
View File

@ -1719,7 +1719,7 @@ static void findKeepUniqueSections(opt::InputArgList &args) {
ArrayRef<Symbol *> syms = obj->getSymbols();
if (obj->addrsigSec) {
ArrayRef<uint8_t> contents =
check(obj->getObj().getSectionContents(obj->addrsigSec));
check(obj->getObj().getSectionContents(*obj->addrsigSec));
const uint8_t *cur = contents.begin();
while (cur != contents.end()) {
unsigned size;

30
lld/ELF/InputFiles.cpp
View File

@ -348,9 +348,9 @@ template <class ELFT> void ELFFileBase::init() {
// Initialize trivial attributes.
const ELFFile<ELFT> &obj = getObj<ELFT>();
emachine = obj.getHeader()->e_machine;
osabi = obj.getHeader()->e_ident[llvm::ELF::EI_OSABI];
abiVersion = obj.getHeader()->e_ident[llvm::ELF::EI_ABIVERSION];
emachine = obj.getHeader().e_machine;
osabi = obj.getHeader().e_ident[llvm::ELF::EI_OSABI];
abiVersion = obj.getHeader().e_ident[llvm::ELF::EI_ABIVERSION];
ArrayRef<Elf_Shdr> sections = CHECK(obj.sections(), this);
@ -378,7 +378,7 @@ template <class ELFT> void ELFFileBase::init() {
template <class ELFT>
uint32_t ObjFile<ELFT>::getSectionIndex(const Elf_Sym &sym) const {
return CHECK(
this->getObj().getSectionIndex(&sym, getELFSyms<ELFT>(), shndxTable),
this->getObj().getSectionIndex(sym, getELFSyms<ELFT>(), shndxTable),
this);
}
@ -566,7 +566,7 @@ void ObjFile<ELFT>::initializeSections(bool ignoreComdats) {
if (sec.sh_type == ELF::SHT_LLVM_CALL_GRAPH_PROFILE)
cgProfile =
check(obj.template getSectionContentsAsArray<Elf_CGProfile>(&sec));
check(obj.template getSectionContentsAsArray<Elf_CGProfile>(sec));
// SHF_EXCLUDE'ed sections are discarded by the linker. However,
// if -r is given, we'll let the final link discard such sections.
@ -595,7 +595,7 @@ void ObjFile<ELFT>::initializeSections(bool ignoreComdats) {
ArrayRef<Elf_Word> entries =
CHECK(obj.template getSectionContentsAsArray<Elf_Word>(&sec), this);
CHECK(obj.template getSectionContentsAsArray<Elf_Word>(sec), this);
if (entries.empty())
fatal(toString(this) + ": empty SHT_GROUP");
@ -870,7 +870,7 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec) {
if (config->emachine == EM_ARM && sec.sh_type == SHT_ARM_ATTRIBUTES) {
ARMAttributeParser attributes;
ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(&sec));
ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(sec));
if (Error e = attributes.parse(contents, config->ekind == ELF32LEKind
? support::little
: support::big)) {
@ -894,7 +894,7 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec) {
if (config->emachine == EM_RISCV && sec.sh_type == SHT_RISCV_ATTRIBUTES) {
RISCVAttributeParser attributes;
ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(&sec));
ArrayRef<uint8_t> contents = check(this->getObj().getSectionContents(sec));
if (Error e = attributes.parse(contents, support::little)) {
auto *isec = make<InputSection>(*this, sec, name);
warn(toString(isec) + ": " + llvm::toString(std::move(e)));
@ -919,7 +919,7 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec) {
if (config->relocatable)
break;
ArrayRef<char> data =
CHECK(this->getObj().template getSectionContentsAsArray<char>(&sec), this);
CHECK(this->getObj().template getSectionContentsAsArray<char>(sec), this);
if (!data.empty() && data.back() != '\0') {
error(toString(this) +
": corrupted dependent libraries section (unterminated string): " +
@ -959,12 +959,12 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec) {
": multiple relocation sections to one section are not supported");
if (sec.sh_type == SHT_RELA) {
ArrayRef<Elf_Rela> rels = CHECK(getObj().relas(&sec), this);
ArrayRef<Elf_Rela> rels = CHECK(getObj().relas(sec), this);
target->firstRelocation = rels.begin();
target->numRelocations = rels.size();
target->areRelocsRela = true;
} else {
ArrayRef<Elf_Rel> rels = CHECK(getObj().rels(&sec), this);
ArrayRef<Elf_Rel> rels = CHECK(getObj().rels(sec), this);
target->firstRelocation = rels.begin();
target->numRelocations = rels.size();
target->areRelocsRela = false;
@ -1065,7 +1065,7 @@ InputSectionBase *ObjFile<ELFT>::createInputSection(const Elf_Shdr &sec) {
template <class ELFT>
StringRef ObjFile<ELFT>::getSectionName(const Elf_Shdr &sec) {
return CHECK(getObj().getSectionName(&sec, sectionStringTable), this);
return CHECK(getObj().getSectionName(sec, sectionStringTable), this);
}
// Initialize this->Symbols. this->Symbols is a parallel array as
@ -1279,7 +1279,7 @@ std::vector<uint32_t> SharedFile::parseVerneed(const ELFFile<ELFT> &obj,
if (!sec)
return {};
std::vector<uint32_t> verneeds;
ArrayRef<uint8_t> data = CHECK(obj.getSectionContents(sec), this);
ArrayRef<uint8_t> data = CHECK(obj.getSectionContents(*sec), this);
const uint8_t *verneedBuf = data.begin();
for (unsigned i = 0; i != sec->sh_info; ++i) {
if (verneedBuf + sizeof(typename ELFT::Verneed) > data.end())
@ -1355,7 +1355,7 @@ template <class ELFT> void SharedFile::parse() {
continue;
case SHT_DYNAMIC:
dynamicTags =
CHECK(obj.template getSectionContentsAsArray<Elf_Dyn>(&sec), this);
CHECK(obj.template getSectionContentsAsArray<Elf_Dyn>(sec), this);
break;
case SHT_GNU_versym:
versymSec = &sec;
@ -1414,7 +1414,7 @@ template <class ELFT> void SharedFile::parse() {
std::vector<uint16_t> versyms(size, VER_NDX_GLOBAL);
if (versymSec) {
ArrayRef<Elf_Versym> versym =
CHECK(obj.template getSectionContentsAsArray<Elf_Versym>(versymSec),
CHECK(obj.template getSectionContentsAsArray<Elf_Versym>(*versymSec),
this)
.slice(firstGlobal);
for (size_t i = 0; i < size; ++i)

4
lld/ELF/InputSection.cpp
View File

@ -53,7 +53,7 @@ static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> &file,
const typename ELFT::Shdr &hdr) {
if (hdr.sh_type == SHT_NOBITS)
return makeArrayRef<uint8_t>(nullptr, hdr.sh_size);
return check(file.getObj().getSectionContents(&hdr));
return check(file.getObj().getSectionContents(hdr));
}
InputSectionBase::InputSectionBase(InputFile *file, uint64_t flags,
@ -456,7 +456,7 @@ void InputSection::copyRelocations(uint8_t *buf, ArrayRef<RelTy> rels) {
Elf_Shdr_Impl<ELFT> sec =
CHECK(file->getObj().sections(), file)[secIdx];
warn("relocation refers to a discarded section: " +
CHECK(file->getObj().getSectionName(&sec), file) +
CHECK(file->getObj().getSectionName(sec), file) +
"\n>>> referenced by " + getObjMsg(p->r_offset));
}
p->setSymbolAndType(0, 0, false);

2
lld/ELF/Relocations.cpp
View File

@ -692,7 +692,7 @@ static std::string maybeReportDiscarded(Undefined &sym) {
if (sym.type == ELF::STT_SECTION) {
msg = "relocation refers to a discarded section: ";
msg += CHECK(
file->getObj().getSectionName(&objSections[sym.discardedSecIdx]), file);
file->getObj().getSectionName(objSections[sym.discardedSecIdx]), file);
} else {
msg = "relocation refers to a symbol in a discarded section: " +
toString(sym);

201
llvm/include/llvm/Object/ELF.h
View File

@ -58,11 +58,11 @@ enum PPCInstrMasks : uint64_t {
template <class ELFT> class ELFFile;
template <class ELFT>
std::string getSecIndexForError(const ELFFile<ELFT> *Obj,
const typename ELFT::Shdr *Sec) {
auto TableOrErr = Obj->sections();
std::string getSecIndexForError(const ELFFile<ELFT> &Obj,
const typename ELFT::Shdr &Sec) {
auto TableOrErr = Obj.sections();
if (TableOrErr)
return "[index " + std::to_string(Sec - &TableOrErr->front()) + "]";
return "[index " + std::to_string(&Sec - &TableOrErr->front()) + "]";
// To make this helper be more convenient for error reporting purposes we
// drop the error. But really it should never be triggered. Before this point,
// our code should have called 'sections()' and reported a proper error on
@ -72,11 +72,11 @@ std::string getSecIndexForError(const ELFFile<ELFT> *Obj,
}
template <class ELFT>
std::string getPhdrIndexForError(const ELFFile<ELFT> *Obj,
const typename ELFT::Phdr *Phdr) {
auto Headers = Obj->program_headers();
std::string getPhdrIndexForError(const ELFFile<ELFT> &Obj,
const typename ELFT::Phdr &Phdr) {
auto Headers = Obj.program_headers();
if (Headers)
return ("[index " + Twine(Phdr - &Headers->front()) + "]").str();
return ("[index " + Twine(&Phdr - &Headers->front()) + "]").str();
// See comment in the getSecIndexForError() above.
llvm::consumeError(Headers.takeError());
return "[unknown index]";
@ -134,17 +134,17 @@ private:
ELFFile(StringRef Object);
public:
const Elf_Ehdr *getHeader() const {
return reinterpret_cast<const Elf_Ehdr *>(base());
const Elf_Ehdr &getHeader() const {
return *reinterpret_cast<const Elf_Ehdr *>(base());
}
template <typename T>
Expected<const T *> getEntry(uint32_t Section, uint32_t Entry) const;
template <typename T>
Expected<const T *> getEntry(const Elf_Shdr *Section, uint32_t Entry) const;
Expected<const T *> getEntry(const Elf_Shdr &Section, uint32_t Entry) const;
Expected<StringRef>
getStringTable(const Elf_Shdr *Section,
getStringTable(const Elf_Shdr &Section,
WarningHandler WarnHandler = &defaultWarningHandler) const;
Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section) const;
Expected<StringRef> getStringTableForSymtab(const Elf_Shdr &Section,
@ -163,18 +163,18 @@ public:
std::string getDynamicTagAsString(uint64_t Type) const;
/// Get the symbol for a given relocation.
Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel *Rel,
Expected<const Elf_Sym *> getRelocationSymbol(const Elf_Rel &Rel,
const Elf_Shdr *SymTab) const;
static Expected<ELFFile> create(StringRef Object);
bool isLE() const {
return getHeader()->getDataEncoding() == ELF::ELFDATA2LSB;
return getHeader().getDataEncoding() == ELF::ELFDATA2LSB;
}
bool isMipsELF64() const {
return getHeader()->e_machine == ELF::EM_MIPS &&
getHeader()->getFileClass() == ELF::ELFCLASS64;
return getHeader().e_machine == ELF::EM_MIPS &&
getHeader().getFileClass() == ELF::ELFCLASS64;
}
bool isMips64EL() const { return isMipsELF64() && isLE(); }
@ -188,43 +188,43 @@ public:
Expected<Elf_Sym_Range> symbols(const Elf_Shdr *Sec) const {
if (!Sec)
return makeArrayRef<Elf_Sym>(nullptr, nullptr);
return getSectionContentsAsArray<Elf_Sym>(Sec);
return getSectionContentsAsArray<Elf_Sym>(*Sec);
}
Expected<Elf_Rela_Range> relas(const Elf_Shdr *Sec) const {
Expected<Elf_Rela_Range> relas(const Elf_Shdr &Sec) const {
return getSectionContentsAsArray<Elf_Rela>(Sec);
}
Expected<Elf_Rel_Range> rels(const Elf_Shdr *Sec) const {
Expected<Elf_Rel_Range> rels(const Elf_Shdr &Sec) const {
return getSectionContentsAsArray<Elf_Rel>(Sec);
}
Expected<Elf_Relr_Range> relrs(const Elf_Shdr *Sec) const {
Expected<Elf_Relr_Range> relrs(const Elf_Shdr &Sec) const {
return getSectionContentsAsArray<Elf_Relr>(Sec);
}
std::vector<Elf_Rel> decode_relrs(Elf_Relr_Range relrs) const;
Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr *Sec) const;
Expected<std::vector<Elf_Rela>> android_relas(const Elf_Shdr &Sec) const;
/// Iterate over program header table.
Expected<Elf_Phdr_Range> program_headers() const {
if (getHeader()->e_phnum && getHeader()->e_phentsize != sizeof(Elf_Phdr))
if (getHeader().e_phnum && getHeader().e_phentsize != sizeof(Elf_Phdr))
return createError("invalid e_phentsize: " +
Twine(getHeader()->e_phentsize));
Twine(getHeader().e_phentsize));
uint64_t HeadersSize =
(uint64_t)getHeader()->e_phnum * getHeader()->e_phentsize;
uint64_t PhOff = getHeader()->e_phoff;
(uint64_t)getHeader().e_phnum * getHeader().e_phentsize;
uint64_t PhOff = getHeader().e_phoff;
if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize > getBufSize())
return createError("program headers are longer than binary of size " +
Twine(getBufSize()) + ": e_phoff = 0x" +
Twine::utohexstr(getHeader()->e_phoff) +
", e_phnum = " + Twine(getHeader()->e_phnum) +
", e_phentsize = " + Twine(getHeader()->e_phentsize));
Twine::utohexstr(getHeader().e_phoff) +
", e_phnum = " + Twine(getHeader().e_phnum) +
", e_phentsize = " + Twine(getHeader().e_phentsize));
auto *Begin = reinterpret_cast<const Elf_Phdr *>(base() + PhOff);
return makeArrayRef(Begin, Begin + getHeader()->e_phnum);
return makeArrayRef(Begin, Begin + getHeader().e_phnum);
}
/// Get an iterator over notes in a program header.
@ -257,7 +257,7 @@ public:
assert(Shdr.sh_type == ELF::SHT_NOTE && "Shdr is not of type SHT_NOTE");
ErrorAsOutParameter ErrAsOutParam(&Err);
if (Shdr.sh_offset + Shdr.sh_size > getBufSize()) {
Err = createError("SHT_NOTE section " + getSecIndexForError(this, &Shdr) +
Err = createError("SHT_NOTE section " + getSecIndexForError(*this, Shdr) +
" has invalid offset (0x" +
Twine::utohexstr(Shdr.sh_offset) + ") or size (0x" +
Twine::utohexstr(Shdr.sh_size) + ")");
@ -298,12 +298,12 @@ public:
Expected<StringRef> getSectionStringTable(
Elf_Shdr_Range Sections,
WarningHandler WarnHandler = &defaultWarningHandler) const;
Expected<uint32_t> getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
Expected<uint32_t> getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,
ArrayRef<Elf_Word> ShndxTable) const;
Expected<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;
Expected<const Elf_Shdr *> getSection(const Elf_Sym *Sym,
Expected<const Elf_Shdr *> getSection(const Elf_Sym &Sym,
Elf_Sym_Range Symtab,
ArrayRef<Elf_Word> ShndxTable) const;
Expected<const Elf_Shdr *> getSection(uint32_t Index) const;
@ -312,14 +312,14 @@ public:
uint32_t Index) const;
Expected<StringRef>
getSectionName(const Elf_Shdr *Section,
getSectionName(const Elf_Shdr &Section,
WarningHandler WarnHandler = &defaultWarningHandler) const;
Expected<StringRef> getSectionName(const Elf_Shdr *Section,
Expected<StringRef> getSectionName(const Elf_Shdr &Section,
StringRef DotShstrtab) const;
template <typename T>
Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr *Sec) const;
Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
Expected<ArrayRef<uint8_t>> getSegmentContents(const Elf_Phdr *Phdr) const;
Expected<ArrayRef<T>> getSectionContentsAsArray(const Elf_Shdr &Sec) const;
Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr &Sec) const;
Expected<ArrayRef<uint8_t>> getSegmentContents(const Elf_Phdr &Phdr) const;
};
using ELF32LEFile = ELFFile<ELF32LE>;
@ -337,11 +337,11 @@ getSection(typename ELFT::ShdrRange Sections, uint32_t Index) {
template <class ELFT>
inline Expected<uint32_t>
getExtendedSymbolTableIndex(const typename ELFT::Sym *Sym,
const typename ELFT::Sym *FirstSym,
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;
assert(Sym.st_shndx == ELF::SHN_XINDEX);
unsigned Index = &Sym - &FirstSym;
if (Index >= ShndxTable.size())
return createError(
"extended symbol index (" + Twine(Index) +
@ -354,12 +354,12 @@ getExtendedSymbolTableIndex(const typename ELFT::Sym *Sym,
template <class ELFT>
Expected<uint32_t>
ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
ELFFile<ELFT>::getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms,
ArrayRef<Elf_Word> ShndxTable) const {
uint32_t Index = Sym->st_shndx;
uint32_t Index = Sym.st_shndx;
if (Index == ELF::SHN_XINDEX) {
auto ErrorOrIndex = getExtendedSymbolTableIndex<ELFT>(
Sym, Syms.begin(), ShndxTable);
Expected<uint32_t> ErrorOrIndex =
getExtendedSymbolTableIndex<ELFT>(Sym, *Syms.begin(), ShndxTable);
if (!ErrorOrIndex)
return ErrorOrIndex.takeError();
return *ErrorOrIndex;
@ -371,7 +371,7 @@ ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
template <class ELFT>
Expected<const typename ELFT::Shdr *>
ELFFile<ELFT>::getSection(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
ELFFile<ELFT>::getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab,
ArrayRef<Elf_Word> ShndxTable) const {
auto SymsOrErr = symbols(SymTab);
if (!SymsOrErr)
@ -381,7 +381,7 @@ ELFFile<ELFT>::getSection(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
template <class ELFT>
Expected<const typename ELFT::Shdr *>
ELFFile<ELFT>::getSection(const Elf_Sym *Sym, Elf_Sym_Range Symbols,
ELFFile<ELFT>::getSection(const Elf_Sym &Sym, Elf_Sym_Range Symbols,
ArrayRef<Elf_Word> ShndxTable) const {
auto IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);
if (!IndexOrErr)
@ -402,7 +402,7 @@ ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
Elf_Sym_Range Symbols = *SymsOrErr;
if (Index >= Symbols.size())
return createError("unable to get symbol from section " +
getSecIndexForError(this, Sec) +
getSecIndexForError(*this, *Sec) +
": invalid symbol index (" + Twine(Index) + ")");
return &Symbols[Index];
}
@ -410,26 +410,26 @@ ELFFile<ELFT>::getSymbol(const Elf_Shdr *Sec, uint32_t Index) const {
template <class ELFT>
template <typename T>
Expected<ArrayRef<T>>
ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
if (Sec->sh_entsize != sizeof(T) && sizeof(T) != 1)
return createError("section " + getSecIndexForError(this, Sec) +
" has an invalid sh_entsize: " + Twine(Sec->sh_entsize));
ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr &Sec) const {
if (Sec.sh_entsize != sizeof(T) && sizeof(T) != 1)
return createError("section " + getSecIndexForError(*this, Sec) +
" has an invalid sh_entsize: " + Twine(Sec.sh_entsize));
uintX_t Offset = Sec->sh_offset;
uintX_t Size = Sec->sh_size;
uintX_t Offset = Sec.sh_offset;
uintX_t Size = Sec.sh_size;
if (Size % sizeof(T))
return createError("section " + getSecIndexForError(this, Sec) +
return createError("section " + getSecIndexForError(*this, Sec) +
" has an invalid sh_size (" + Twine(Size) +
") which is not a multiple of its sh_entsize (" +
Twine(Sec->sh_entsize) + ")");
Twine(Sec.sh_entsize) + ")");
if (std::numeric_limits<uintX_t>::max() - Offset < Size)
return createError("section " + getSecIndexForError(this, Sec) +
return createError("section " + getSecIndexForError(*this, Sec) +
" has a sh_offset (0x" + Twine::utohexstr(Offset) +
") + sh_size (0x" + Twine::utohexstr(Size) +
") that cannot be represented");
if (Offset + Size > Buf.size())
return createError("section " + getSecIndexForError(this, Sec) +
return createError("section " + getSecIndexForError(*this, Sec) +
" has a sh_offset (0x" + Twine::utohexstr(Offset) +
") + sh_size (0x" + Twine::utohexstr(Size) +
") that is greater than the file size (0x" +
@ -445,17 +445,17 @@ ELFFile<ELFT>::getSectionContentsAsArray(const Elf_Shdr *Sec) const {
template <class ELFT>
Expected<ArrayRef<uint8_t>>
ELFFile<ELFT>::getSegmentContents(const Elf_Phdr *Phdr) const {
uintX_t Offset = Phdr->p_offset;
uintX_t Size = Phdr->p_filesz;
ELFFile<ELFT>::getSegmentContents(const Elf_Phdr &Phdr) const {
uintX_t Offset = Phdr.p_offset;
uintX_t Size = Phdr.p_filesz;
if (std::numeric_limits<uintX_t>::max() - Offset < Size)
return createError("program header " + getPhdrIndexForError(this, Phdr) +
return createError("program header " + getPhdrIndexForError(*this, Phdr) +
" has a p_offset (0x" + Twine::utohexstr(Offset) +
") + p_filesz (0x" + Twine::utohexstr(Size) +
") that cannot be represented");
if (Offset + Size > Buf.size())
return createError("program header " + getPhdrIndexForError(this, Phdr) +
return createError("program header " + getPhdrIndexForError(*this, Phdr) +
" has a p_offset (0x" + Twine::utohexstr(Offset) +
") + p_filesz (0x" + Twine::utohexstr(Size) +
") that is greater than the file size (0x" +
@ -465,13 +465,13 @@ ELFFile<ELFT>::getSegmentContents(const Elf_Phdr *Phdr) const {
template <class ELFT>
Expected<ArrayRef<uint8_t>>
ELFFile<ELFT>::getSectionContents(const Elf_Shdr *Sec) const {
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);
return getELFRelocationTypeName(getHeader().e_machine, Type);
}
template <class ELFT>
@ -507,24 +507,24 @@ void ELFFile<ELFT>::getRelocationTypeName(uint32_t Type,
template <class ELFT>
uint32_t ELFFile<ELFT>::getRelativeRelocationType() const {
return getELFRelativeRelocationType(getHeader()->e_machine);
return getELFRelativeRelocationType(getHeader().e_machine);
}
template <class ELFT>
Expected<const typename ELFT::Sym *>
ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel *Rel,
ELFFile<ELFT>::getRelocationSymbol(const Elf_Rel &Rel,
const Elf_Shdr *SymTab) const {
uint32_t Index = Rel->getSymbol(isMips64EL());
uint32_t Index = Rel.getSymbol(isMips64EL());
if (Index == 0)
return nullptr;
return getEntry<Elf_Sym>(SymTab, Index);
return getEntry<Elf_Sym>(*SymTab, Index);
}
template <class ELFT>
Expected<StringRef>
ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections,
WarningHandler WarnHandler) const {
uint32_t Index = getHeader()->e_shstrndx;
uint32_t Index = getHeader().e_shstrndx;
if (Index == ELF::SHN_XINDEX) {
// If the section name string table section index is greater than
// or equal to SHN_LORESERVE, then the actual index of the section name
@ -542,7 +542,7 @@ ELFFile<ELFT>::getSectionStringTable(Elf_Shdr_Range Sections,
if (Index >= Sections.size())
return createError("section header string table index " + Twine(Index) +
" does not exist");
return getStringTable(&Sections[Index], WarnHandler);
return getStringTable(Sections[Index], WarnHandler);
}
template <class ELFT> ELFFile<ELFT>::ELFFile(StringRef Object) : Buf(Object) {}
@ -558,13 +558,13 @@ Expected<ELFFile<ELFT>> ELFFile<ELFT>::create(StringRef Object) {
template <class ELFT>
Expected<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
const uintX_t SectionTableOffset = getHeader()->e_shoff;
const uintX_t SectionTableOffset = getHeader().e_shoff;
if (SectionTableOffset == 0)
return ArrayRef<Elf_Shdr>();
if (getHeader()->e_shentsize != sizeof(Elf_Shdr))
if (getHeader().e_shentsize != sizeof(Elf_Shdr))
return createError("invalid e_shentsize in ELF header: " +
Twine(getHeader()->e_shentsize));
Twine(getHeader().e_shentsize));
const uint64_t FileSize = Buf.size();
if (SectionTableOffset + sizeof(Elf_Shdr) > FileSize ||
@ -581,7 +581,7 @@ Expected<typename ELFT::ShdrRange> ELFFile<ELFT>::sections() const {
const Elf_Shdr *First =
reinterpret_cast<const Elf_Shdr *>(base() + SectionTableOffset);
uintX_t NumSections = getHeader()->e_shnum;
uintX_t NumSections = getHeader().e_shnum;
if (NumSections == 0)
NumSections = First->sh_size;
@ -612,21 +612,21 @@ Expected<const T *> ELFFile<ELFT>::getEntry(uint32_t Section,
auto SecOrErr = getSection(Section);
if (!SecOrErr)
return SecOrErr.takeError();
return getEntry<T>(*SecOrErr, Entry);
return getEntry<T>(**SecOrErr, Entry);
}
template <class ELFT>
template <typename T>
Expected<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 createError("section " + getSecIndexForError(this, Section) +
if (sizeof(T) != Section.sh_entsize)
return createError("section " + getSecIndexForError(*this, Section) +
" has invalid sh_entsize: expected " + Twine(sizeof(T)) +
", but got " + Twine(Section->sh_entsize));
uint64_t Pos = Section->sh_offset + (uint64_t)Entry * sizeof(T);
", but got " + Twine(Section.sh_entsize));
uint64_t Pos = Section.sh_offset + (uint64_t)Entry * sizeof(T);
if (Pos + sizeof(T) > Buf.size())
return createError("unable to access section " +
getSecIndexForError(this, Section) + " data at 0x" +
getSecIndexForError(*this, Section) + " data at 0x" +
Twine::utohexstr(Pos) +
": offset goes past the end of file");
return reinterpret_cast<const T *>(base() + Pos);
@ -643,14 +643,14 @@ ELFFile<ELFT>::getSection(uint32_t Index) const {
template <class ELFT>
Expected<StringRef>
ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section,
ELFFile<ELFT>::getStringTable(const Elf_Shdr &Section,
WarningHandler WarnHandler) const {
if (Section->sh_type != ELF::SHT_STRTAB)
if (Section.sh_type != ELF::SHT_STRTAB)
if (Error E = WarnHandler("invalid sh_type for string table section " +
getSecIndexForError(this, Section) +
getSecIndexForError(*this, Section) +
": expected SHT_STRTAB, but got " +
object::getELFSectionTypeName(
getHeader()->e_machine, Section->sh_type)))
getHeader().e_machine, Section.sh_type)))
return std::move(E);
auto V = getSectionContentsAsArray<char>(Section);
@ -659,10 +659,10 @@ ELFFile<ELFT>::getStringTable(const Elf_Shdr *Section,
ArrayRef<char> Data = *V;
if (Data.empty())
return createError("SHT_STRTAB string table section " +
getSecIndexForError(this, Section) + " is empty");
getSecIndexForError(*this, Section) + " is empty");
if (Data.back() != '\0')
return createError("SHT_STRTAB string table section " +
getSecIndexForError(this, Section) +
getSecIndexForError(*this, Section) +
" is non-null terminated");
return StringRef(Data.begin(), Data.size());
}
@ -681,7 +681,7 @@ 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);
auto VOrErr = getSectionContentsAsArray<Elf_Word>(Section);
if (!VOrErr)
return VOrErr.takeError();
ArrayRef<Elf_Word> V = *VOrErr;
@ -691,10 +691,10 @@ ELFFile<ELFT>::getSHNDXTable(const Elf_Shdr &Section,
const Elf_Shdr &SymTable = **SymTableOrErr;
if (SymTable.sh_type != ELF::SHT_SYMTAB &&
SymTable.sh_type != ELF::SHT_DYNSYM)
return createError("SHT_SYMTAB_SHNDX section is linked with " +
object::getELFSectionTypeName(getHeader()->e_machine,
SymTable.sh_type) +
" section (expected SHT_SYMTAB/SHT_DYNSYM)");
return createError(
"SHT_SYMTAB_SHNDX section is linked with " +
object::getELFSectionTypeName(getHeader().e_machine, SymTable.sh_type) +
" section (expected SHT_SYMTAB/SHT_DYNSYM)");
uint64_t Syms = SymTable.sh_size / sizeof(Elf_Sym);
if (V.size() != Syms)
@ -722,15 +722,16 @@ ELFFile<ELFT>::getStringTableForSymtab(const Elf_Shdr &Sec,
if (Sec.sh_type != ELF::SHT_SYMTAB && Sec.sh_type != ELF::SHT_DYNSYM)
return createError(
"invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
auto SectionOrErr = object::getSection<ELFT>(Sections, Sec.sh_link);
Expected<const Elf_Shdr *> SectionOrErr =
object::getSection<ELFT>(Sections, Sec.sh_link);
if (!SectionOrErr)
return SectionOrErr.takeError();
return getStringTable(*SectionOrErr);
return getStringTable(**SectionOrErr);
}
template <class ELFT>
Expected<StringRef>
ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
ELFFile<ELFT>::getSectionName(const Elf_Shdr &Section,
WarningHandler WarnHandler) const {
auto SectionsOrErr = sections();
if (!SectionsOrErr)
@ -742,13 +743,13 @@ ELFFile<ELFT>::getSectionName(const Elf_Shdr *Section,
}
template <class ELFT>
Expected<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;
uint32_t Offset = Section.sh_name;
if (Offset == 0)
return StringRef();
if (Offset >= DotShstrtab.size())
return createError("a section " + getSecIndexForError(this, Section) +
return createError("a section " + getSecIndexForError(*this, Section) +
" has an invalid sh_name (0x" +
Twine::utohexstr(Offset) +
") offset which goes past the end of the "

51
llvm/include/llvm/Object/ELFObjectFile.h
View File

@ -377,7 +377,7 @@ protected:
for (const Elf_Shdr &Sec : *SectionsOrErr) {
if (Sec.sh_type == ELF::SHT_ARM_ATTRIBUTES ||
Sec.sh_type == ELF::SHT_RISCV_ATTRIBUTES) {
auto ErrorOrContents = EF.getSectionContents(&Sec);
auto ErrorOrContents = EF.getSectionContents(Sec);
if (!ErrorOrContents)
return ErrorOrContents.takeError();
@ -432,7 +432,7 @@ public:
Triple::ArchType getArch() const override;
Expected<uint64_t> getStartAddress() const override;
unsigned getPlatformFlags() const override { return EF.getHeader()->e_flags; }
unsigned getPlatformFlags() const override { return EF.getHeader().e_flags; }
const ELFFile<ELFT> *getELFFile() const { return &EF; }
@ -468,7 +468,7 @@ Expected<StringRef> ELFObjectFile<ELFT>::getSymbolName(DataRefImpl Sym) const {
if (!StrTabOrErr)
return StrTabOrErr.takeError();
const Elf_Shdr *StringTableSec = *StrTabOrErr;
auto SymStrTabOrErr = EF.getStringTable(StringTableSec);
auto SymStrTabOrErr = EF.getStringTable(*StringTableSec);
if (!SymStrTabOrErr)
return SymStrTabOrErr.takeError();
Expected<StringRef> Name = ESym->getName(*SymStrTabOrErr);
@ -507,9 +507,9 @@ uint64_t ELFObjectFile<ELFT>::getSymbolValueImpl(DataRefImpl Symb) const {
if (ESym->st_shndx == ELF::SHN_ABS)
return Ret;
const Elf_Ehdr *Header = EF.getHeader();
const Elf_Ehdr &Header = EF.getHeader();
// Clear the ARM/Thumb or microMIPS indicator flag.
if ((Header->e_machine == ELF::EM_ARM || Header->e_machine == ELF::EM_MIPS) &&
if ((Header.e_machine == ELF::EM_ARM || Header.e_machine == ELF::EM_MIPS) &&
ESym->getType() == ELF::STT_FUNC)
Ret &= ~1;
@ -533,14 +533,13 @@ ELFObjectFile<ELFT>::getSymbolAddress(DataRefImpl Symb) const {
return Result;
}
const Elf_Ehdr *Header = EF.getHeader();
auto SymTabOrErr = EF.getSection(Symb.d.a);
if (!SymTabOrErr)
return SymTabOrErr.takeError();
const Elf_Shdr *SymTab = *SymTabOrErr;
if (Header->e_type == ELF::ET_REL) {
auto SectionOrErr = EF.getSection(ESym, SymTab, ShndxTable);
if (EF.getHeader().e_type == ELF::ET_REL) {
Expected<const Elf_Shdr *> SectionOrErr =
EF.getSection(*ESym, *SymTabOrErr, ShndxTable);
if (!SectionOrErr)
return SectionOrErr.takeError();
const Elf_Shdr *Section = *SectionOrErr;
@ -561,11 +560,11 @@ uint32_t ELFObjectFile<ELFT>::getSymbolAlignment(DataRefImpl Symb) const {
template <class ELFT>
uint16_t ELFObjectFile<ELFT>::getEMachine() const {
return EF.getHeader()->e_machine;
return EF.getHeader().e_machine;
}
template <class ELFT> uint16_t ELFObjectFile<ELFT>::getEType() const {
return EF.getHeader()->e_type;
return EF.getHeader().e_type;
}
template <class ELFT>
@ -652,7 +651,7 @@ Expected<uint32_t> ELFObjectFile<ELFT>::getSymbolFlags(DataRefImpl Sym) const {
// TODO: Test this error.
return SymbolsOrErr.takeError();
if (EF.getHeader()->e_machine == ELF::EM_ARM) {
if (EF.getHeader().e_machine == ELF::EM_ARM) {
if (Expected<StringRef> NameOrErr = getSymbolName(Sym)) {
StringRef Name = *NameOrErr;
if (Name.startswith("$d") || Name.startswith("$t") ||
@ -685,7 +684,7 @@ template <class ELFT>
Expected<section_iterator>
ELFObjectFile<ELFT>::getSymbolSection(const Elf_Sym *ESym,
const Elf_Shdr *SymTab) const {
auto ESecOrErr = EF.getSection(ESym, SymTab, ShndxTable);
auto ESecOrErr = EF.getSection(*ESym, SymTab, ShndxTable);
if (!ESecOrErr)
return ESecOrErr.takeError();
@ -717,7 +716,7 @@ void ELFObjectFile<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
template <class ELFT>
Expected<StringRef> ELFObjectFile<ELFT>::getSectionName(DataRefImpl Sec) const {
return EF.getSectionName(&*getSection(Sec));
return EF.getSectionName(*getSection(Sec));
}
template <class ELFT>
@ -847,7 +846,7 @@ ELFObjectFile<ELFT>::section_rel_begin(DataRefImpl Sec) const {
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.a = (Sec.p - SHT) / EF.getHeader().e_shentsize;
RelData.d.b = 0;
return relocation_iterator(RelocationRef(RelData, this));
}
@ -874,7 +873,7 @@ ELFObjectFile<ELFT>::section_rel_end(DataRefImpl Sec) const {
template <class ELFT>
Expected<section_iterator>
ELFObjectFile<ELFT>::getRelocatedSection(DataRefImpl Sec) const {
if (EF.getHeader()->e_type != ELF::ET_REL)
if (EF.getHeader().e_type != ELF::ET_REL)
return section_end();
const Elf_Shdr *EShdr = getSection(Sec);
@ -933,7 +932,7 @@ uint64_t ELFObjectFile<ELFT>::getRelocationType(DataRefImpl Rel) const {
template <class ELFT>
StringRef ELFObjectFile<ELFT>::getRelocationTypeName(uint32_t Type) const {
return getELFRelocationTypeName(EF.getHeader()->e_machine, Type);
return getELFRelocationTypeName(EF.getHeader().e_machine, Type);
}
template <class ELFT>
@ -1087,9 +1086,9 @@ uint8_t ELFObjectFile<ELFT>::getBytesInAddress() const {
template <class ELFT>
StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
bool IsLittleEndian = ELFT::TargetEndianness == support::little;
switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
case ELF::ELFCLASS32:
switch (EF.getHeader()->e_machine) {
switch (EF.getHeader().e_machine) {
case ELF::EM_386:
return "elf32-i386";
case ELF::EM_IAMCU:
@ -1123,7 +1122,7 @@ StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
return "elf32-unknown";
}
case ELF::ELFCLASS64:
switch (EF.getHeader()->e_machine) {
switch (EF.getHeader().e_machine) {
case ELF::EM_386:
return "elf64-i386";
case ELF::EM_X86_64:
@ -1157,7 +1156,7 @@ StringRef ELFObjectFile<ELFT>::getFileFormatName() const {
template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
bool IsLittleEndian = ELFT::TargetEndianness == support::little;
switch (EF.getHeader()->e_machine) {
switch (EF.getHeader().e_machine) {
case ELF::EM_386:
case ELF::EM_IAMCU:
return Triple::x86;
@ -1174,7 +1173,7 @@ template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
case ELF::EM_LANAI:
return Triple::lanai;
case ELF::EM_MIPS:
switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
case ELF::ELFCLASS32:
return IsLittleEndian ? Triple::mipsel : Triple::mips;
case ELF::ELFCLASS64:
@ -1189,7 +1188,7 @@ template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
case ELF::EM_PPC64:
return IsLittleEndian ? Triple::ppc64le : Triple::ppc64;
case ELF::EM_RISCV:
switch (EF.getHeader()->e_ident[ELF::EI_CLASS]) {
switch (EF.getHeader().e_ident[ELF::EI_CLASS]) {
case ELF::ELFCLASS32:
return Triple::riscv32;
case ELF::ELFCLASS64:
@ -1210,7 +1209,7 @@ template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
if (!IsLittleEndian)
return Triple::UnknownArch;
unsigned MACH = EF.getHeader()->e_flags & ELF::EF_AMDGPU_MACH;
unsigned MACH = EF.getHeader().e_flags & ELF::EF_AMDGPU_MACH;
if (MACH >= ELF::EF_AMDGPU_MACH_R600_FIRST &&
MACH <= ELF::EF_AMDGPU_MACH_R600_LAST)
return Triple::r600;
@ -1235,7 +1234,7 @@ template <class ELFT> Triple::ArchType ELFObjectFile<ELFT>::getArch() const {
template <class ELFT>
Expected<uint64_t> ELFObjectFile<ELFT>::getStartAddress() const {
return EF.getHeader()->e_entry;
return EF.getHeader().e_entry;
}
template <class ELFT>
@ -1245,7 +1244,7 @@ ELFObjectFile<ELFT>::getDynamicSymbolIterators() const {
}
template <class ELFT> bool ELFObjectFile<ELFT>::isRelocatableObject() const {
return EF.getHeader()->e_type == ELF::ET_REL;
return EF.getHeader().e_type == ELF::ET_REL;
}
} // end namespace object

24
llvm/lib/ExecutionEngine/JITLink/ELF_x86_64.cpp
View File

@ -244,7 +244,7 @@ private:
object::ELFFile<object::ELF64LE>::Elf_Shdr_Range sections;
SymbolTable SymTab;
bool isRelocatable() { return Obj.getHeader()->e_type == llvm::ELF::ET_REL; }
bool isRelocatable() { return Obj.getHeader().e_type == llvm::ELF::ET_REL; }
support::endianness
getEndianness(const object::ELFFile<object::ELF64LE> &Obj) {
@ -253,7 +253,7 @@ private:
// This could also just become part of a template
unsigned getPointerSize(const object::ELFFile<object::ELF64LE> &Obj) {
return Obj.getHeader()->getFileClass() == ELF::ELFCLASS64 ? 8 : 4;
return Obj.getHeader().getFileClass() == ELF::ELFCLASS64 ? 8 : 4;
}
// We don't technically need this right now
@ -277,7 +277,7 @@ private:
auto StrTabSec = Obj.getSection(SecRef.sh_link);
if (!StrTabSec)
return StrTabSec.takeError();
auto StringTable = Obj.getStringTable(*StrTabSec);
auto StringTable = Obj.getStringTable(**StrTabSec);
if (!StringTable)
return StringTable.takeError();
@ -310,7 +310,7 @@ private:
Error createNormalizedSections() {
LLVM_DEBUG(dbgs() << "Creating normalized sections...\n");
for (auto &SecRef : sections) {
auto Name = Obj.getSectionName(&SecRef);
auto Name = Obj.getSectionName(SecRef);
if (!Name)
return Name.takeError();
sys::Memory::ProtectionFlags Prot;
@ -343,7 +343,7 @@ private:
if (SecRef.sh_type != ELF::SHT_NOBITS) {
// .sections() already checks that the data is not beyond the end of
// file
auto contents = Obj.getSectionContentsAsArray<char>(&SecRef);
auto contents = Obj.getSectionContentsAsArray<char>(SecRef);
if (!contents)
return contents.takeError();
@ -375,7 +375,7 @@ private:
return make_error<llvm::StringError>("Shouldn't have REL in x64",
llvm::inconvertibleErrorCode());
auto RelSectName = Obj.getSectionName(&SecRef);
auto RelSectName = Obj.getSectionName(SecRef);
if (!RelSectName)
return RelSectName.takeError();
// Deal with .eh_frame later
@ -386,7 +386,7 @@ private:
if (!UpdateSection)
return UpdateSection.takeError();
auto UpdateSectionName = Obj.getSectionName(*UpdateSection);
auto UpdateSectionName = Obj.getSectionName(**UpdateSection);
if (!UpdateSectionName)
return UpdateSectionName.takeError();
@ -397,7 +397,7 @@ private:
*UpdateSectionName,
llvm::inconvertibleErrorCode());
auto Relocations = Obj.relas(&SecRef);
auto Relocations = Obj.relas(SecRef);
if (!Relocations)
return Relocations.takeError();
@ -409,7 +409,7 @@ private:
<< "Name: " << Obj.getRelocationTypeName(Type) << "\n";
});
auto SymbolIndex = Rela.getSymbol(false);
auto Symbol = Obj.getRelocationSymbol(&Rela, &SymTab);
auto Symbol = Obj.getRelocationSymbol(Rela, &SymTab);
if (!Symbol)
return Symbol.takeError();
@ -472,10 +472,10 @@ private:
auto StrTabSec = Obj.getSection(SecRef.sh_link);
if (!StrTabSec)
return StrTabSec.takeError();
auto StringTable = Obj.getStringTable(*StrTabSec);
auto StringTable = Obj.getStringTable(**StrTabSec);
if (!StringTable)
return StringTable.takeError();
auto Name = Obj.getSectionName(&SecRef);
auto Name = Obj.getSectionName(SecRef);
if (!Name)
return Name.takeError();
auto Section = G->findSectionByName(*Name);
@ -520,7 +520,7 @@ private:
auto DefinedSection = Obj.getSection(SymRef.st_shndx);
if (!DefinedSection)
return DefinedSection.takeError();
auto sectName = Obj.getSectionName(*DefinedSection);
auto sectName = Obj.getSectionName(**DefinedSection);
if (!sectName)
return Name.takeError();

2
llvm/lib/InterfaceStub/ELFObjHandler.cpp
View File

@ -320,7 +320,7 @@ buildStub(const ELFObjectFile<ELFT> &ElfObj) {
DynEnt.StrSize);
// Populate Arch from ELF header.
DestStub->Arch = ElfFile->getHeader()->e_machine;
DestStub->Arch = ElfFile->getHeader().e_machine;
// Populate SoName from .dynamic entries and dynamic string table.
if (DynEnt.SONameOffset.hasValue()) {

6
llvm/lib/Object/ELF.cpp
View File

@ -366,7 +366,7 @@ ELFFile<ELFT>::decode_relrs(Elf_Relr_Range relrs) const {
template <class ELFT>
Expected<std::vector<typename ELFT::Rela>>
ELFFile<ELFT>::android_relas(const Elf_Shdr *Sec) const {
ELFFile<ELFT>::android_relas(const Elf_Shdr &Sec) const {
// This function reads relocations in Android's packed relocation format,
// which is based on SLEB128 and delta encoding.
Expected<ArrayRef<uint8_t>> ContentsOrErr = getSectionContents(Sec);
@ -511,7 +511,7 @@ std::string ELFFile<ELFT>::getDynamicTagAsString(unsigned Arch,
template <class ELFT>
std::string ELFFile<ELFT>::getDynamicTagAsString(uint64_t Type) const {
return getDynamicTagAsString(getHeader()->e_machine, Type);
return getDynamicTagAsString(getHeader().e_machine, Type);
}
template <class ELFT>
@ -541,7 +541,7 @@ Expected<typename ELFT::DynRange> ELFFile<ELFT>::dynamicEntries() const {
for (const Elf_Shdr &Sec : *SectionsOrError) {
if (Sec.sh_type == ELF::SHT_DYNAMIC) {
Expected<ArrayRef<Elf_Dyn>> DynOrError =
getSectionContentsAsArray<Elf_Dyn>(&Sec);
getSectionContentsAsArray<Elf_Dyn>(Sec);
if (!DynOrError)
return DynOrError.takeError();
Dyn = *DynOrError;

30
llvm/tools/llvm-objcopy/ELF/Object.cpp
View File

@ -1320,7 +1320,7 @@ void ELFBuilder<ELFT>::readProgramHeaders(const ELFFile<ELFT> &HeadersFile) {
ElfHdr.Index = Index++;
ElfHdr.OriginalOffset = ElfHdr.Offset = EhdrOffset;
const auto &Ehdr = *HeadersFile.getHeader();
const typename ELFT::Ehdr &Ehdr = HeadersFile.getHeader();
auto &PrHdr = Obj.ProgramHdrSegment;
PrHdr.Type = PT_PHDR;
PrHdr.Flags = 0;
@ -1398,7 +1398,7 @@ void ELFBuilder<ELFT>::initSymbolTable(SymbolTableSection *SymTab) {
const Elf_Shdr &ShndxSec =
*unwrapOrError(ElfFile.getSection(SymTab->getShndxTable()->Index));
ShndxData = unwrapOrError(
ElfFile.template getSectionContentsAsArray<Elf_Word>(&ShndxSec));
ElfFile.template getSectionContentsAsArray<Elf_Word>(ShndxSec));
if (ShndxData.size() != Symbols.size())
error("symbol section index table does not have the same number of "
"entries as the symbol table");
@ -1476,7 +1476,7 @@ SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
case SHT_REL:
case SHT_RELA:
if (Shdr.sh_flags & SHF_ALLOC) {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<DynamicRelocationSection>(Data);
}
return Obj.addSection<RelocationSection>();
@ -1485,7 +1485,7 @@ SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
// mean altering the memory image. There are no special link types or
// anything so we can just use a Section.
if (Shdr.sh_flags & SHF_ALLOC) {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<Section>(Data);
}
return Obj.addSection<StringTableSection>();
@ -1493,16 +1493,16 @@ SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
case SHT_GNU_HASH:
// Hash tables should refer to SHT_DYNSYM which we're not going to change.
// Because of this we don't need to mess with the hash tables either.
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<Section>(Data);
case SHT_GROUP:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<GroupSection>(Data);
case SHT_DYNSYM:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<DynamicSymbolTableSection>(Data);
case SHT_DYNAMIC:
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
return Obj.addSection<DynamicSection>(Data);
case SHT_SYMTAB: {
auto &SymTab = Obj.addSection<SymbolTableSection>();
@ -1517,9 +1517,9 @@ SectionBase &ELFBuilder<ELFT>::makeSection(const Elf_Shdr &Shdr) {
case SHT_NOBITS:
return Obj.addSection<Section>(Data);
default: {
Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
Data = unwrapOrError(ElfFile.getSectionContents(Shdr));
StringRef Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
StringRef Name = unwrapOrError(ElfFile.getSectionName(Shdr));
if (Name.startswith(".zdebug") || (Shdr.sh_flags & ELF::SHF_COMPRESSED)) {
uint64_t DecompressedSize, DecompressedAlign;
std::tie(DecompressedSize, DecompressedAlign) =
@ -1541,7 +1541,7 @@ template <class ELFT> void ELFBuilder<ELFT>::readSectionHeaders() {
continue;
}
auto &Sec = makeSection(Shdr);
Sec.Name = std::string(unwrapOrError(ElfFile.getSectionName(&Shdr)));
Sec.Name = std::string(unwrapOrError(ElfFile.getSectionName(Shdr)));
Sec.Type = Sec.OriginalType = Shdr.sh_type;
Sec.Flags = Sec.OriginalFlags = Shdr.sh_flags;
Sec.Addr = Shdr.sh_addr;
@ -1560,7 +1560,7 @@ template <class ELFT> void ELFBuilder<ELFT>::readSectionHeaders() {
}
template <class ELFT> void ELFBuilder<ELFT>::readSections(bool EnsureSymtab) {
uint32_t ShstrIndex = ElfFile.getHeader()->e_shstrndx;
uint32_t ShstrIndex = ElfFile.getHeader().e_shstrndx;
if (ShstrIndex == SHN_XINDEX)
ShstrIndex = unwrapOrError(ElfFile.getSection(0))->sh_link;
@ -1602,10 +1602,10 @@ template <class ELFT> void ELFBuilder<ELFT>::readSections(bool EnsureSymtab) {
auto Shdr = unwrapOrError(ElfFile.sections()).begin() + RelSec->Index;
if (RelSec->Type == SHT_REL)
initRelocations(RelSec, Obj.SymbolTable,
unwrapOrError(ElfFile.rels(Shdr)));
unwrapOrError(ElfFile.rels(*Shdr)));
else
initRelocations(RelSec, Obj.SymbolTable,
unwrapOrError(ElfFile.relas(Shdr)));
unwrapOrError(ElfFile.relas(*Shdr)));
} else if (auto GroupSec = dyn_cast<GroupSection>(&Sec)) {
initGroupSection(GroupSec);
}
@ -1622,7 +1622,7 @@ template <class ELFT> void ELFBuilder<ELFT>::build(bool EnsureSymtab) {
ELFFile<ELFT> HeadersFile = unwrapOrError(ELFFile<ELFT>::create(toStringRef(
{ElfFile.base() + EhdrOffset, ElfFile.getBufSize() - EhdrOffset})));
auto &Ehdr = *HeadersFile.getHeader();
auto &Ehdr = HeadersFile.getHeader();
Obj.OSABI = Ehdr.e_ident[EI_OSABI];
Obj.ABIVersion = Ehdr.e_ident[EI_ABIVERSION];
Obj.Type = Ehdr.e_type;

6
llvm/tools/llvm-objdump/ELFDump.cpp
View File

@ -92,7 +92,7 @@ static Error getRelocationValueString(const ELFObjectFile<ELFT> *Obj,
return SymSI.takeError();
const typename ELFT::Shdr *SymSec =
Obj->getSection((*SymSI)->getRawDataRefImpl());
auto SecName = EF.getSectionName(SymSec);
auto SecName = EF.getSectionName(*SymSec);
if (!SecName)
return SecName.takeError();
Fmt << *SecName;
@ -338,10 +338,10 @@ static void printSymbolVersionInfo(const ELFFile<ELFT> *Elf,
continue;
ArrayRef<uint8_t> Contents =
unwrapOrError(Elf->getSectionContents(&Shdr), FileName);
unwrapOrError(Elf->getSectionContents(Shdr), FileName);
const typename ELFT::Shdr *StrTabSec =
unwrapOrError(Elf->getSection(Shdr.sh_link), FileName);
StringRef StrTab = unwrapOrError(Elf->getStringTable(StrTabSec), FileName);
StringRef StrTab = unwrapOrError(Elf->getStringTable(*StrTabSec), FileName);
if (Shdr.sh_type == ELF::SHT_GNU_verneed)
printSymbolVersionDependency<ELFT>(Contents, StrTab);

14
llvm/tools/llvm-readobj/ARMEHABIPrinter.h
View File

@ -407,7 +407,7 @@ PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
reportError(SymTabOrErr.takeError(), FileName);
const Elf_Shdr *SymTab = *SymTabOrErr;
for (const Elf_Rel &R : unwrapOrError(FileName, ELF->rels(&Sec))) {
for (const Elf_Rel &R : unwrapOrError(FileName, ELF->rels(Sec))) {
if (R.r_offset != static_cast<unsigned>(IndexTableOffset))
continue;
@ -417,9 +417,9 @@ PrinterContext<ET>::FindExceptionTable(unsigned IndexSectionIndex,
RelA.r_addend = 0;
const Elf_Sym *Symbol =
unwrapOrError(FileName, ELF->getRelocationSymbol(&RelA, SymTab));
unwrapOrError(FileName, ELF->getRelocationSymbol(RelA, SymTab));
auto Ret = ELF->getSection(Symbol, SymTab, ShndxTable);
auto Ret = ELF->getSection(*Symbol, SymTab, ShndxTable);
if (!Ret)
report_fatal_error(errorToErrorCode(Ret.takeError()).message());
return *Ret;
@ -432,7 +432,7 @@ template <typename ET>
void PrinterContext<ET>::PrintExceptionTable(const Elf_Shdr *IT,
const Elf_Shdr *EHT,
uint64_t TableEntryOffset) const {
Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(EHT);
Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(*EHT);
if (!Contents)
return;
@ -499,7 +499,7 @@ void PrinterContext<ET>::PrintOpcodes(const uint8_t *Entry,
template <typename ET>
void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
const Elf_Shdr *IT) const {
Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(IT);
Expected<ArrayRef<uint8_t>> Contents = ELF->getSectionContents(*IT);
if (!Contents)
return;
@ -553,7 +553,7 @@ void PrinterContext<ET>::PrintIndexTable(unsigned SectionIndex,
FindExceptionTable(SectionIndex, Entry * IndexTableEntrySize + 4);
if (EHT)
if (auto Name = ELF->getSectionName(EHT))
if (auto Name = ELF->getSectionName(*EHT))
SW.printString("ExceptionHandlingTable", *Name);
uint64_t TableEntryOffset = PREL31(Word1, IT->sh_addr);
@ -575,7 +575,7 @@ void PrinterContext<ET>::PrintUnwindInformation() const {
DictScope UIT(SW, "UnwindIndexTable");
SW.printNumber("SectionIndex", SectionIndex);
if (auto SectionName = ELF->getSectionName(&Sec))
if (auto SectionName = ELF->getSectionName(Sec))
SW.printString("SectionName", *SectionName);
SW.printHex("SectionOffset", Sec.sh_offset);

8
llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h
View File

@ -85,7 +85,7 @@ void PrinterContext<ELFT>::printUnwindInformation() const {
reportError(SectionsOrErr.takeError(), ObjF->getFileName());
for (const Elf_Shdr &Shdr : *SectionsOrErr) {
Expected<StringRef> NameOrErr = Obj->getSectionName(&Shdr);
Expected<StringRef> NameOrErr = Obj->getSectionName(Shdr);
if (!NameOrErr)
reportError(NameOrErr.takeError(), ObjF->getFileName());
if (*NameOrErr == ".eh_frame")
@ -104,13 +104,13 @@ void PrinterContext<ELFT>::printEHFrameHdr(const Elf_Phdr *EHFramePHdr) const {
const object::ELFFile<ELFT> *Obj = ObjF->getELFFile();
if (const Elf_Shdr *EHFrameHdr =
findSectionByAddress(ObjF, EHFramePHdr->p_vaddr)) {
Expected<StringRef> NameOrErr = Obj->getSectionName(EHFrameHdr);
Expected<StringRef> NameOrErr = Obj->getSectionName(*EHFrameHdr);
if (!NameOrErr)
reportError(NameOrErr.takeError(), ObjF->getFileName());
W.printString("Corresponding Section", *NameOrErr);
}
Expected<ArrayRef<uint8_t>> Content = Obj->getSegmentContents(EHFramePHdr);
Expected<ArrayRef<uint8_t>> Content = Obj->getSegmentContents(*EHFramePHdr);
if (!Content)
reportError(Content.takeError(), ObjF->getFileName());
@ -181,7 +181,7 @@ void PrinterContext<ELFT>::printEHFrame(const Elf_Shdr *EHFrameShdr) const {
W.indent();
Expected<ArrayRef<uint8_t>> DataOrErr =
ObjF->getELFFile()->getSectionContents(EHFrameShdr);
ObjF->getELFFile()->getSectionContents(*EHFrameShdr);
if (!DataOrErr)
reportError(DataOrErr.takeError(), ObjF->getFileName());

287
llvm/tools/llvm-readobj/ELFDumper.cpp
View File

@ -404,7 +404,7 @@ template <class ELFT>
static std::string describe(const ELFFile<ELFT> &Obj,
const typename ELFT::Shdr &Sec) {
unsigned SecNdx = &Sec - &cantFail(Obj.sections()).front();
return (object::getELFSectionTypeName(Obj.getHeader()->e_machine,
return (object::getELFSectionTypeName(Obj.getHeader().e_machine,
Sec.sh_type) +
" section with index " + Twine(SecNdx))
.str();
@ -424,7 +424,7 @@ static Expected<StringRef> getLinkAsStrtab(const ELFFile<ELFT> &Obj,
return createError("invalid section linked to " + describe(Obj, *Sec) +
": " + toString(StrTabSecOrErr.takeError()));
Expected<StringRef> StrTabOrErr = Obj.getStringTable(*StrTabSecOrErr);
Expected<StringRef> StrTabOrErr = Obj.getStringTable(**StrTabSecOrErr);
if (!StrTabOrErr)
return createError("invalid string table linked to " + describe(Obj, *Sec) +
": " + toString(StrTabOrErr.takeError()));
@ -443,13 +443,12 @@ getLinkAsSymtab(const ELFFile<ELFT> &Obj, const typename ELFT::Shdr *Sec,
": " + toString(SymtabOrErr.takeError()));
if ((*SymtabOrErr)->sh_type != ExpectedType)
return createError("invalid section linked to " + describe(Obj, *Sec) +
": expected " +
object::getELFSectionTypeName(Obj.getHeader()->e_machine,
ExpectedType) +
", but got " +
object::getELFSectionTypeName(Obj.getHeader()->e_machine,
(*SymtabOrErr)->sh_type));
return createError(
"invalid section linked to " + describe(Obj, *Sec) + ": expected " +
object::getELFSectionTypeName(Obj.getHeader().e_machine, ExpectedType) +
", but got " +
object::getELFSectionTypeName(Obj.getHeader().e_machine,
(*SymtabOrErr)->sh_type));
Expected<StringRef> StrTabOrErr = getLinkAsStrtab(Obj, *SymtabOrErr);
if (!StrTabOrErr)
@ -477,7 +476,7 @@ ELFDumper<ELFT>::getVersionTable(const Elf_Shdr *Sec, ArrayRef<Elf_Sym> *SymTab,
return createError("the " + describe(*Sec) + " is misaligned");
Expected<ArrayRef<Elf_Versym>> VersionsOrErr =
Obj->template getSectionContentsAsArray<Elf_Versym>(Sec);
Obj->template getSectionContentsAsArray<Elf_Versym>(*Sec);
if (!VersionsOrErr)
return createError("cannot read content of " + describe(*Sec) + ": " +
toString(VersionsOrErr.takeError()));
@ -511,7 +510,7 @@ ELFDumper<ELFT>::getVersionDefinitions(const Elf_Shdr *Sec) const {
if (!StrTabOrErr)
return StrTabOrErr.takeError();
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(Sec);
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(*Sec);
if (!ContentsOrErr)
return createError("cannot read content of " + describe(*Sec) + ": " +
toString(ContentsOrErr.takeError()));
@ -600,7 +599,7 @@ ELFDumper<ELFT>::getVersionDependencies(const Elf_Shdr *Sec) const {
else
StrTab = *StrTabOrErr;
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(Sec);
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj->getSectionContents(*Sec);
if (!ContentsOrErr)
return createError("cannot read content of " + describe(*Sec) + ": " +
toString(ContentsOrErr.takeError()));
@ -1069,7 +1068,7 @@ Expected<StringRef> ELFDumper<ELFT>::getSymbolVersion(const Elf_Sym *Sym,
// Get the corresponding version index entry.
if (Expected<const Elf_Versym *> EntryOrErr =
ObjF->getELFFile()->template getEntry<Elf_Versym>(
SymbolVersionSection, EntryIndex))
*SymbolVersionSection, EntryIndex))
return this->getSymbolVersionByIndex((*EntryOrErr)->vs_index, IsDefault);
else
return EntryOrErr.takeError();
@ -1084,7 +1083,7 @@ ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
const ELFFile<ELFT> &Obj = *ObjF->getELFFile();
Expected<const Elf_Sym *> SymOrErr =
Obj.template getEntry<Elf_Sym>(SymTab, R.Symbol);
Obj.template getEntry<Elf_Sym>(*SymTab, R.Symbol);
if (!SymOrErr)
return SymOrErr.takeError();
const Elf_Sym *Sym = *SymOrErr;
@ -1095,14 +1094,14 @@ ELFDumper<ELFT>::getRelocationTarget(const Relocation<ELFT> &R,
// This code block returns the section name.
if (Sym->getType() == ELF::STT_SECTION) {
Expected<const Elf_Shdr *> SecOrErr =
Obj.getSection(Sym, SymTab, ShndxTable);
Obj.getSection(*Sym, SymTab, ShndxTable);
if (!SecOrErr)
return SecOrErr.takeError();
// A section symbol describes the section at index 0.
if (*SecOrErr == nullptr)
return RelSymbol<ELFT>(Sym, "");
Expected<StringRef> NameOrErr = Obj.getSectionName(*SecOrErr);
Expected<StringRef> NameOrErr = Obj.getSectionName(**SecOrErr);
if (!NameOrErr)
return NameOrErr.takeError();
return RelSymbol<ELFT>(Sym, NameOrErr->str());
@ -1227,7 +1226,7 @@ Expected<unsigned>
ELFDumper<ELFT>::getSymbolSectionIndex(const Elf_Sym *Symbol,
const Elf_Sym *FirstSym) const {
return Symbol->st_shndx == SHN_XINDEX
? object::getExtendedSymbolTableIndex<ELFT>(Symbol, FirstSym,
? object::getExtendedSymbolTableIndex<ELFT>(*Symbol, *FirstSym,
ShndxTable)
: Symbol->st_shndx;
}
@ -1259,7 +1258,7 @@ ELFDumper<ELFT>::getSymbolSectionName(const Elf_Sym *Symbol,
Obj->getSection(SectionIndex);
if (!SecOrErr)
return SecOrErr.takeError();
return Obj->getSectionName(*SecOrErr);
return Obj->getSectionName(**SecOrErr);
}
template <class ELFO>
@ -2423,7 +2422,7 @@ const typename ELFT::Shdr *
ELFDumper<ELFT>::findSectionByName(StringRef Name) const {
const ELFFile<ELFT> *Obj = ObjF->getELFFile();
for (const Elf_Shdr &Shdr : cantFail(Obj->sections())) {
if (Expected<StringRef> NameOrErr = Obj->getSectionName(&Shdr)) {
if (Expected<StringRef> NameOrErr = Obj->getSectionName(Shdr)) {
if (*NameOrErr == Name)
return &Shdr;
} else {
@ -2456,7 +2455,7 @@ std::string ELFDumper<ELFT>::getDynamicEntry(uint64_t Type,
};
// Handle custom printing of architecture specific tags
switch (ObjF->getELFFile()->getHeader()->e_machine) {
switch (ObjF->getELFFile()->getHeader().e_machine) {
case EM_AARCH64:
switch (Type) {
case DT_AARCH64_BTI_PLT:
@ -2653,7 +2652,7 @@ namespace {
template <> void ELFDumper<ELF32LE>::printUnwindInfo() {
const ELFFile<ELF32LE> *Obj = ObjF->getELFFile();
const unsigned Machine = Obj->getHeader()->e_machine;
const unsigned Machine = Obj->getHeader().e_machine;
if (Machine == EM_ARM) {
ARM::EHABI::PrinterContext<ELF32LE> Ctx(W, Obj, ObjF->getFileName(),
DotSymtabSec);
@ -2832,7 +2831,7 @@ template <typename ELFT> void ELFDumper<ELFT>::printLoadName() {
template <class ELFT> void ELFDumper<ELFT>::printArchSpecificInfo() {
const ELFFile<ELFT> *Obj = ObjF->getELFFile();
switch (Obj->getHeader()->e_machine) {
switch (Obj->getHeader().e_machine) {
case EM_ARM:
case EM_RISCV:
printAttributes();
@ -2867,7 +2866,7 @@ template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
return;
}
const unsigned Machine = Obj->getHeader()->e_machine;
const unsigned Machine = Obj->getHeader().e_machine;
assert((Machine == EM_ARM || Machine == EM_RISCV) &&
"Attributes not implemented.");
@ -2878,7 +2877,7 @@ template <class ELFT> void ELFDumper<ELFT>::printAttributes() {
continue;
ArrayRef<uint8_t> Contents =
unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(&Sec));
unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(Sec));
if (Contents[0] != ELFAttrs::Format_Version) {
reportWarning(createError(Twine("unrecognised FormatVersion: 0x") +
Twine::utohexstr(Contents[0])),
@ -2978,7 +2977,7 @@ Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable,
return Error::success();
ArrayRef<uint8_t> Content =
unwrapOrError(FileName, Obj->getSectionContents(GotSec));
unwrapOrError(FileName, Obj->getSectionContents(*GotSec));
GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
Content.size() / sizeof(Entry));
LocalNum = GotEntries.size();
@ -3028,7 +3027,7 @@ Error MipsGOTParser<ELFT>::findGOT(Elf_Dyn_Range DynTable,
GlobalNum = DynSymTotal - *DtGotSym;
ArrayRef<uint8_t> Content =
unwrapOrError(FileName, Obj->getSectionContents(GotSec));
unwrapOrError(FileName, Obj->getSectionContents(*GotSec));
GotEntries = Entries(reinterpret_cast<const Entry *>(Content.data()),
Content.size() / sizeof(Entry));
GotDynSyms = DynSyms.drop_front(*DtGotSym);
@ -3072,7 +3071,7 @@ Error MipsGOTParser<ELFT>::findPLT(Elf_Dyn_Range DynTable) {
Twine::utohexstr(*DtJmpRel));
if (Expected<ArrayRef<uint8_t>> PltContentOrErr =
Obj->getSectionContents(PltSec))
Obj->getSectionContents(*PltSec))
PltEntries =
Entries(reinterpret_cast<const Entry *>(PltContentOrErr->data()),
PltContentOrErr->size() / sizeof(Entry));
@ -3196,13 +3195,13 @@ const typename MipsGOTParser<ELFT>::Elf_Sym *
MipsGOTParser<ELFT>::getPltSym(const Entry *E) const {
int64_t Offset = std::distance(getPltEntries().data(), E);
if (PltRelSec->sh_type == ELF::SHT_REL) {
Elf_Rel_Range Rels = unwrapOrError(FileName, Obj->rels(PltRelSec));
Elf_Rel_Range Rels = unwrapOrError(FileName, Obj->rels(*PltRelSec));
return unwrapOrError(FileName,
Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
Obj->getRelocationSymbol(Rels[Offset], PltSymTable));
} else {
Elf_Rela_Range Rels = unwrapOrError(FileName, Obj->relas(PltRelSec));
Elf_Rela_Range Rels = unwrapOrError(FileName, Obj->relas(*PltRelSec));
return unwrapOrError(FileName,
Obj->getRelocationSymbol(&Rels[Offset], PltSymTable));
Obj->getRelocationSymbol(Rels[Offset], PltSymTable));
}
}
@ -3299,7 +3298,7 @@ template <class ELFT> void ELFDumper<ELFT>::printMipsReginfo() {
const ELFFile<ELFT> *Obj = ObjF->getELFFile();
Expected<ArrayRef<uint8_t>> ContentsOrErr =
Obj->getSectionContents(RegInfoSec);
Obj->getSectionContents(*RegInfoSec);
if (!ContentsOrErr) {
this->reportUniqueWarning(createError(
"unable to read the content of the .reginfo section (" +
@ -3367,7 +3366,7 @@ template <class ELFT> void ELFDumper<ELFT>::printMipsOptions() {
DictScope GS(W, "MIPS Options");
ArrayRef<uint8_t> Data =
unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(MipsOpts));
unwrapOrError(ObjF->getFileName(), Obj->getSectionContents(*MipsOpts));
const uint8_t *const SecBegin = Data.begin();
while (!Data.empty()) {
bool IsSupported;
@ -3407,7 +3406,7 @@ template <class ELFT> void ELFDumper<ELFT>::printStackMap() const {
};
Expected<ArrayRef<uint8_t>> ContentOrErr =
Obj->getSectionContents(StackMapSection);
Obj->getSectionContents(*StackMapSection);
if (!ContentOrErr) {
Warn(ContentOrErr.takeError());
return;
@ -3442,9 +3441,9 @@ static inline void printFields(formatted_raw_ostream &OS, StringRef Str1,
template <class ELFT>
static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj,
StringRef FileName) {
const typename ELFT::Ehdr *ElfHeader = Obj.getHeader();
if (ElfHeader->e_shnum != 0)
return to_string(ElfHeader->e_shnum);
const typename ELFT::Ehdr &ElfHeader = Obj.getHeader();
if (ElfHeader.e_shnum != 0)
return to_string(ElfHeader.e_shnum);
ArrayRef<typename ELFT::Shdr> Arr = cantFail(Obj.sections());
if (Arr.empty())
@ -3455,71 +3454,71 @@ static std::string getSectionHeadersNumString(const ELFFile<ELFT> &Obj,
template <class ELFT>
static std::string getSectionHeaderTableIndexString(const ELFFile<ELFT> &Obj,
StringRef FileName) {
const typename ELFT::Ehdr *ElfHeader = Obj.getHeader();
if (ElfHeader->e_shstrndx != SHN_XINDEX)
return to_string(ElfHeader->e_shstrndx);
const typename ELFT::Ehdr &ElfHeader = Obj.getHeader();
if (ElfHeader.e_shstrndx != SHN_XINDEX)
return to_string(ElfHeader.e_shstrndx);
ArrayRef<typename ELFT::Shdr> Arr = cantFail(Obj.sections());
if (Arr.empty())
return "65535 (corrupt: out of range)";
return to_string(ElfHeader->e_shstrndx) + " (" + to_string(Arr[0].sh_link) +
return to_string(ElfHeader.e_shstrndx) + " (" + to_string(Arr[0].sh_link) +
")";
}
template <class ELFT> void GNUStyle<ELFT>::printFileHeaders() {
const Elf_Ehdr *e = this->Obj.getHeader();
const Elf_Ehdr &e = this->Obj.getHeader();
OS << "ELF Header:\n";
OS << " Magic: ";
std::string Str;
for (int i = 0; i < ELF::EI_NIDENT; i++)
OS << format(" %02x", static_cast<int>(e->e_ident[i]));
OS << format(" %02x", static_cast<int>(e.e_ident[i]));
OS << "\n";
Str = printEnum(e->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
Str = printEnum(e.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
printFields(OS, "Class:", Str);
Str = printEnum(e->e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
Str = printEnum(e.e_ident[ELF::EI_DATA], makeArrayRef(ElfDataEncoding));
printFields(OS, "Data:", Str);
OS.PadToColumn(2u);
OS << "Version:";
OS.PadToColumn(37u);
OS << to_hexString(e->e_ident[ELF::EI_VERSION]);
if (e->e_version == ELF::EV_CURRENT)
OS << to_hexString(e.e_ident[ELF::EI_VERSION]);
if (e.e_version == ELF::EV_CURRENT)
OS << " (current)";
OS << "\n";
Str = printEnum(e->e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
Str = printEnum(e.e_ident[ELF::EI_OSABI], makeArrayRef(ElfOSABI));
printFields(OS, "OS/ABI:", Str);
printFields(OS,
"ABI Version:", std::to_string(e->e_ident[ELF::EI_ABIVERSION]));
Str = printEnum(e->e_type, makeArrayRef(ElfObjectFileType));
"ABI Version:", std::to_string(e.e_ident[ELF::EI_ABIVERSION]));
Str = printEnum(e.e_type, makeArrayRef(ElfObjectFileType));
printFields(OS, "Type:", Str);
Str = printEnum(e->e_machine, makeArrayRef(ElfMachineType));
Str = printEnum(e.e_machine, makeArrayRef(ElfMachineType));
printFields(OS, "Machine:", Str);
Str = "0x" + to_hexString(e->e_version);
Str = "0x" + to_hexString(e.e_version);
printFields(OS, "Version:", Str);
Str = "0x" + to_hexString(e->e_entry);
Str = "0x" + to_hexString(e.e_entry);
printFields(OS, "Entry point address:", Str);
Str = to_string(e->e_phoff) + " (bytes into file)";
Str = to_string(e.e_phoff) + " (bytes into file)";
printFields(OS, "Start of program headers:", Str);
Str = to_string(e->e_shoff) + " (bytes into file)";
Str = to_string(e.e_shoff) + " (bytes into file)";
printFields(OS, "Start of section headers:", Str);
std::string ElfFlags;
if (e->e_machine == EM_MIPS)
if (e.e_machine == EM_MIPS)
ElfFlags =
printFlags(e->e_flags, makeArrayRef(ElfHeaderMipsFlags),
printFlags(e.e_flags, makeArrayRef(ElfHeaderMipsFlags),
unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
unsigned(ELF::EF_MIPS_MACH));
else if (e->e_machine == EM_RISCV)
ElfFlags = printFlags(e->e_flags, makeArrayRef(ElfHeaderRISCVFlags));
Str = "0x" + to_hexString(e->e_flags);
else if (e.e_machine == EM_RISCV)
ElfFlags = printFlags(e.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
Str = "0x" + to_hexString(e.e_flags);
if (!ElfFlags.empty())
Str = Str + ", " + ElfFlags;
printFields(OS, "Flags:", Str);
Str = to_string(e->e_ehsize) + " (bytes)";
Str = to_string(e.e_ehsize) + " (bytes)";
printFields(OS, "Size of this header:", Str);
Str = to_string(e->e_phentsize) + " (bytes)";
Str = to_string(e.e_phentsize) + " (bytes)";
printFields(OS, "Size of program headers:", Str);
Str = to_string(e->e_phnum);
Str = to_string(e.e_phnum);
printFields(OS, "Number of program headers:", Str);
Str = to_string(e->e_shentsize) + " (bytes)";
Str = to_string(e.e_shentsize) + " (bytes)";
printFields(OS, "Size of section headers:", Str);
Str = getSectionHeadersNumString(this->Obj, this->FileName);
printFields(OS, "Number of section headers:", Str);
@ -3563,11 +3562,11 @@ std::vector<GroupSection> getGroups(const ELFFile<ELFT> &Obj,
StringRef StrTable =
unwrapOrError(FileName, Obj.getStringTableForSymtab(*Symtab));
const Elf_Sym *Sym = unwrapOrError(
FileName, Obj.template getEntry<Elf_Sym>(Symtab, Sec.sh_info));
FileName, Obj.template getEntry<Elf_Sym>(*Symtab, Sec.sh_info));
auto Data = unwrapOrError(
FileName, Obj.template getSectionContentsAsArray<Elf_Word>(&Sec));
FileName, Obj.template getSectionContentsAsArray<Elf_Word>(Sec));
StringRef Name = unwrapOrError(FileName, Obj.getSectionName(&Sec));
StringRef Name = unwrapOrError(FileName, Obj.getSectionName(Sec));
StringRef Signature = StrTable.data() + Sym->st_name;
Ret.push_back({Name,
maybeDemangle(Signature),
@ -3580,7 +3579,7 @@ std::vector<GroupSection> getGroups(const ELFFile<ELFT> &Obj,
std::vector<GroupMember> &GM = Ret.back().Members;
for (uint32_t Ndx : Data.slice(1)) {
auto Sec = unwrapOrError(FileName, Obj.getSection(Ndx));
const Elf_Shdr &Sec = *unwrapOrError(FileName, Obj.getSection(Ndx));
const StringRef Name = unwrapOrError(FileName, Obj.getSectionName(Sec));
GM.push_back({Name, Ndx});
}
@ -3727,7 +3726,7 @@ template <class ELFT> void GNUStyle<ELFT>::printRelocations() {
if (Sec.sh_type == ELF::SHT_ANDROID_REL ||
Sec.sh_type == ELF::SHT_ANDROID_RELA) {
Expected<std::vector<typename ELFT::Rela>> RelasOrErr =
this->Obj.android_relas(&Sec);
this->Obj.android_relas(Sec);
if (!RelasOrErr)
return RelasOrErr.takeError();
return RelasOrErr->size();
@ -3735,7 +3734,7 @@ template <class ELFT> void GNUStyle<ELFT>::printRelocations() {
if (!opts::RawRelr && (Sec.sh_type == ELF::SHT_RELR ||
Sec.sh_type == ELF::SHT_ANDROID_RELR)) {
Expected<Elf_Relr_Range> RelrsOrErr = this->Obj.relrs(&Sec);
Expected<Elf_Relr_Range> RelrsOrErr = this->Obj.relrs(Sec);
if (!RelrsOrErr)
return RelrsOrErr.takeError();
return this->Obj.decode_relrs(*RelrsOrErr).size();
@ -3827,7 +3826,7 @@ template <class ELFT> void GNUStyle<ELFT>::printSectionHeaders() {
ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
OS << "There are " << to_string(Sections.size())
<< " section headers, starting at offset "
<< "0x" << to_hexString(this->Obj.getHeader()->e_shoff, false) << ":\n\n";
<< "0x" << to_hexString(this->Obj.getHeader().e_shoff, false) << ":\n\n";
OS << "Section Headers:\n";
Field Fields[11] = {
{"[Nr]", 2}, {"Name", 7}, {"Type", 25},
@ -3852,15 +3851,15 @@ template <class ELFT> void GNUStyle<ELFT>::printSectionHeaders() {
Fields[1].Str = "<no-strings>";
else
Fields[1].Str = std::string(unwrapOrError<StringRef>(
this->FileName, this->Obj.getSectionName(&Sec, SecStrTable)));
this->FileName, this->Obj.getSectionName(Sec, SecStrTable)));
Fields[2].Str =
getSectionTypeString(this->Obj.getHeader()->e_machine, Sec.sh_type);
getSectionTypeString(this->Obj.getHeader().e_machine, Sec.sh_type);
Fields[3].Str =
to_string(format_hex_no_prefix(Sec.sh_addr, ELFT::Is64Bits ? 16 : 8));
Fields[4].Str = to_string(format_hex_no_prefix(Sec.sh_offset, 6));
Fields[5].Str = to_string(format_hex_no_prefix(Sec.sh_size, 6));
Fields[6].Str = to_string(format_hex_no_prefix(Sec.sh_entsize, 2));
Fields[7].Str = getGNUFlags(this->Obj.getHeader()->e_machine, Sec.sh_flags);
Fields[7].Str = getGNUFlags(this->Obj.getHeader().e_machine, Sec.sh_flags);
Fields[8].Str = to_string(Sec.sh_link);
Fields[9].Str = to_string(Sec.sh_info);
Fields[10].Str = to_string(Sec.sh_addralign);
@ -3880,7 +3879,7 @@ template <class ELFT> void GNUStyle<ELFT>::printSectionHeaders() {
OS << "\n";
++SectionIndex;
}
printSectionDescription(OS, this->Obj.getHeader()->e_machine);
printSectionDescription(OS, this->Obj.getHeader().e_machine);
}
template <class ELFT>
@ -3918,7 +3917,7 @@ std::string GNUStyle<ELFT>::getSymbolSectionNdx(const Elf_Sym *Symbol,
return "COM";
case ELF::SHN_XINDEX: {
Expected<uint32_t> IndexOrErr = object::getExtendedSymbolTableIndex<ELFT>(
Symbol, FirstSym, this->dumper()->getShndxTable());
*Symbol, *FirstSym, this->dumper()->getShndxTable());
if (!IndexOrErr) {
assert(Symbol->st_shndx == SHN_XINDEX &&
"getSymbolSectionIndex should only fail due to an invalid "
@ -3961,7 +3960,7 @@ void GNUStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Sym *FirstSym,
Fields[2].Str = to_string(format_decimal(Symbol->st_size, 5));
unsigned char SymbolType = Symbol->getType();
if (this->Obj.getHeader()->e_machine == ELF::EM_AMDGPU &&
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
Fields[3].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
else
@ -4000,7 +3999,7 @@ void GNUStyle<ELFT>::printHashedSymbol(const Elf_Sym *FirstSym, uint32_t Sym,
Fields[3].Str = to_string(format_decimal(Symbol->st_size, 5));
unsigned char SymbolType = Symbol->getType();
if (this->Obj.getHeader()->e_machine == ELF::EM_AMDGPU &&
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
Fields[4].Str = printEnum(SymbolType, makeArrayRef(AMDGPUSymbolTypes));
else
@ -4227,14 +4226,14 @@ void GNUStyle<ELFT>::printProgramHeaders(
template <class ELFT> void GNUStyle<ELFT>::printProgramHeaders() {
unsigned Bias = ELFT::Is64Bits ? 8 : 0;
const Elf_Ehdr *Header = this->Obj.getHeader();
const Elf_Ehdr &Header = this->Obj.getHeader();
Field Fields[8] = {2, 17, 26, 37 + Bias,
48 + Bias, 56 + Bias, 64 + Bias, 68 + Bias};
OS << "\nElf file type is "
<< printEnum(Header->e_type, makeArrayRef(ElfObjectFileType)) << "\n"
<< "Entry point " << format_hex(Header->e_entry, 3) << "\n"
<< "There are " << Header->e_phnum << " program headers,"
<< " starting at offset " << Header->e_phoff << "\n\n"
<< printEnum(Header.e_type, makeArrayRef(ElfObjectFileType)) << "\n"
<< "Entry point " << format_hex(Header.e_entry, 3) << "\n"
<< "There are " << Header.e_phnum << " program headers,"
<< " starting at offset " << Header.e_phoff << "\n\n"
<< "Program Headers:\n";
if (ELFT::Is64Bits)
OS << " Type Offset VirtAddr PhysAddr "
@ -4254,7 +4253,7 @@ template <class ELFT> void GNUStyle<ELFT>::printProgramHeaders() {
}
for (const Elf_Phdr &Phdr : *PhdrsOrErr) {
Fields[0].Str = getGNUPtType(Header->e_machine, Phdr.p_type);
Fields[0].Str = getGNUPtType(Header.e_machine, Phdr.p_type);
Fields[1].Str = to_string(format_hex(Phdr.p_offset, 8));
Fields[2].Str = to_string(format_hex(Phdr.p_vaddr, Width));
Fields[3].Str = to_string(format_hex(Phdr.p_paddr, Width));
@ -4322,8 +4321,7 @@ template <class ELFT> void GNUStyle<ELFT>::printSectionMapping() {
if (checkTLSSections<ELFT>(Phdr, Sec) && checkOffsets<ELFT>(Phdr, Sec) &&
checkVMA<ELFT>(Phdr, Sec) && checkPTDynamic<ELFT>(Phdr, Sec)) {
Sections +=
unwrapOrError(this->FileName, this->Obj.getSectionName(&Sec))
.str() +
unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() +
" ";
BelongsToSegment.insert(&Sec);
}
@ -4337,7 +4335,7 @@ template <class ELFT> void GNUStyle<ELFT>::printSectionMapping() {
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
if (BelongsToSegment.find(&Sec) == BelongsToSegment.end())
Sections +=
unwrapOrError(this->FileName, this->Obj.getSectionName(&Sec)).str() +
unwrapOrError(this->FileName, this->Obj.getSectionName(Sec)).str() +
' ';
}
if (!Sections.empty()) {
@ -4478,7 +4476,7 @@ template <class ELFT>
void GNUStyle<ELFT>::printGNUVersionSectionProlog(
const typename ELFT::Shdr *Sec, const Twine &Label, unsigned EntriesNum) {
StringRef SecName =
unwrapOrError(this->FileName, this->Obj.getSectionName(Sec));
unwrapOrError(this->FileName, this->Obj.getSectionName(*Sec));
OS << Label << " section '" << SecName << "' "
<< "contains " << EntriesNum << " entries:\n";
@ -4487,7 +4485,7 @@ void GNUStyle<ELFT>::printGNUVersionSectionProlog(
this->Obj.getSection(Sec->sh_link);
if (SymTabOrErr)
SymTabName =
unwrapOrError(this->FileName, this->Obj.getSectionName(*SymTabOrErr));
unwrapOrError(this->FileName, this->Obj.getSectionName(**SymTabOrErr));
else
this->reportUniqueWarning(createError("invalid section linked to " +
describe(this->Obj, *Sec) + ": " +
@ -5273,7 +5271,7 @@ template <class ELFT> void GNUStyle<ELFT>::printNotes() {
<< format_hex(Descriptor.size(), 10) << '\t';
StringRef NoteType =
getNoteTypeName<ELFT>(Note, this->Obj.getHeader()->e_type);
getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type);
if (!NoteType.empty())
OS << NoteType << '\n';
else
@ -5311,11 +5309,11 @@ template <class ELFT> void GNUStyle<ELFT>::printNotes() {
};
ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
if (this->Obj.getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
for (const auto &S : Sections) {
if (this->Obj.getHeader().e_type != ELF::ET_CORE && !Sections.empty()) {
for (const Elf_Shdr &S : Sections) {
if (S.sh_type != SHT_NOTE)
continue;
PrintHeader(expectedToOptional(this->Obj.getSectionName(&S)), S.sh_offset,
PrintHeader(expectedToOptional(this->Obj.getSectionName(S)), S.sh_offset,
S.sh_size);
Error Err = Error::success();
for (auto Note : this->Obj.notes(S, Err))
@ -5367,7 +5365,7 @@ void DumpStyle<ELFT>::printDependentLibsHelper(
OnSectionStart(Shdr);
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(&Shdr);
Expected<ArrayRef<uint8_t>> ContentsOrErr = Obj.getSectionContents(Shdr);
if (!ContentsOrErr) {
Warn(I, toString(ContentsOrErr.takeError()));
continue;
@ -5412,7 +5410,7 @@ void DumpStyle<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) {
const bool IsMips64EL = this->Obj.isMips64EL();
switch (Sec.sh_type) {
case ELF::SHT_REL:
if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(&Sec)) {
if (Expected<Elf_Rel_Range> RangeOrErr = Obj.rels(Sec)) {
for (const Elf_Rel &R : *RangeOrErr)
printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
} else {
@ -5420,7 +5418,7 @@ void DumpStyle<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) {
}
break;
case ELF::SHT_RELA:
if (Expected<Elf_Rela_Range> RangeOrErr = Obj.relas(&Sec)) {
if (Expected<Elf_Rela_Range> RangeOrErr = Obj.relas(Sec)) {
for (const Elf_Rela &R : *RangeOrErr)
printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
} else {
@ -5429,7 +5427,7 @@ void DumpStyle<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) {
break;
case ELF::SHT_RELR:
case ELF::SHT_ANDROID_RELR: {
Expected<Elf_Relr_Range> RangeOrErr = Obj.relrs(&Sec);
Expected<Elf_Relr_Range> RangeOrErr = Obj.relrs(Sec);
if (!RangeOrErr) {
Warn(RangeOrErr.takeError());
break;
@ -5447,7 +5445,7 @@ void DumpStyle<ELFT>::printRelocationsHelper(const Elf_Shdr &Sec) {
}
case ELF::SHT_ANDROID_REL:
case ELF::SHT_ANDROID_RELA:
if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj.android_relas(&Sec)) {
if (Expected<std::vector<Elf_Rela>> RelasOrErr = Obj.android_relas(Sec)) {
for (const Elf_Rela &R : *RelasOrErr)
printReloc(Relocation<ELFT>(R, IsMips64EL), ++RelNdx, Sec, SymTab);
} else {
@ -5461,7 +5459,7 @@ template <class ELFT>
StringRef DumpStyle<ELFT>::getPrintableSectionName(const Elf_Shdr &Sec) const {
StringRef Name = "<?>";
if (Expected<StringRef> SecNameOrErr =
Obj.getSectionName(&Sec, this->dumper()->WarningHandler))
Obj.getSectionName(Sec, this->dumper()->WarningHandler))
Name = *SecNameOrErr;
else
this->reportUniqueWarning(createError("unable to get the name of " +
@ -5659,7 +5657,7 @@ void DumpStyle<ELFT>::printNonRelocatableStackSizes(
PrintHeader();
const Elf_Shdr *ElfSec = Obj->getSection(Sec.getRawDataRefImpl());
ArrayRef<uint8_t> Contents =
unwrapOrError(this->FileName, EF->getSectionContents(ElfSec));
unwrapOrError(this->FileName, EF->getSectionContents(*ElfSec));
DataExtractor Data(Contents, Obj->isLittleEndian(), sizeof(Elf_Addr));
uint64_t Offset = 0;
while (Offset < Contents.size()) {
@ -5724,7 +5722,7 @@ void DumpStyle<ELFT>::printRelocatableStackSizes(
const Elf_Shdr *ContentsSec =
Obj->getSection((*RelSecOrErr)->getRawDataRefImpl());
Expected<StringRef> ContentsSectionNameOrErr =
EF->getSectionName(ContentsSec);
EF->getSectionName(*ContentsSec);
if (!ContentsSectionNameOrErr) {
consumeError(ContentsSectionNameOrErr.takeError());
continue;
@ -5936,7 +5934,7 @@ getMipsAbiFlagsSection(const ELFObjectFile<ELFT> *ObjF,
const ELFFile<ELFT> *Obj = ObjF->getELFFile();
constexpr StringRef ErrPrefix = "unable to read the .MIPS.abiflags section: ";
Expected<ArrayRef<uint8_t>> DataOrErr = Obj->getSectionContents(Sec);
Expected<ArrayRef<uint8_t>> DataOrErr = Obj->getSectionContents(*Sec);
if (!DataOrErr)
return createError(ErrPrefix + toString(DataOrErr.takeError()));
@ -5981,21 +5979,21 @@ void GNUStyle<ELFT>::printMipsABIFlags(const ELFObjectFile<ELFT> *ObjF) {
}
template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders() {
const Elf_Ehdr *E = this->Obj.getHeader();
const Elf_Ehdr &E = this->Obj.getHeader();
{
DictScope D(W, "ElfHeader");
{
DictScope D(W, "Ident");
W.printBinary("Magic", makeArrayRef(E->e_ident).slice(ELF::EI_MAG0, 4));
W.printEnum("Class", E->e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
W.printEnum("DataEncoding", E->e_ident[ELF::EI_DATA],
W.printBinary("Magic", makeArrayRef(E.e_ident).slice(ELF::EI_MAG0, 4));
W.printEnum("Class", E.e_ident[ELF::EI_CLASS], makeArrayRef(ElfClass));
W.printEnum("DataEncoding", E.e_ident[ELF::EI_DATA],
makeArrayRef(ElfDataEncoding));
W.printNumber("FileVersion", E->e_ident[ELF::EI_VERSION]);
W.printNumber("FileVersion", E.e_ident[ELF::EI_VERSION]);
auto OSABI = makeArrayRef(ElfOSABI);
if (E->e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH &&
E->e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) {
switch (E->e_machine) {
if (E.e_ident[ELF::EI_OSABI] >= ELF::ELFOSABI_FIRST_ARCH &&
E.e_ident[ELF::EI_OSABI] <= ELF::ELFOSABI_LAST_ARCH) {
switch (E.e_machine) {
case ELF::EM_AMDGPU:
OSABI = makeArrayRef(AMDGPUElfOSABI);
break;
@ -6007,32 +6005,32 @@ template <class ELFT> void LLVMStyle<ELFT>::printFileHeaders() {
break;
}
}
W.printEnum("OS/ABI", E->e_ident[ELF::EI_OSABI], OSABI);
W.printNumber("ABIVersion", E->e_ident[ELF::EI_ABIVERSION]);
W.printBinary("Unused", makeArrayRef(E->e_ident).slice(ELF::EI_PAD));
W.printEnum("OS/ABI", E.e_ident[ELF::EI_OSABI], OSABI);
W.printNumber("ABIVersion", E.e_ident[ELF::EI_ABIVERSION]);
W.printBinary("Unused", makeArrayRef(E.e_ident).slice(ELF::EI_PAD));
}
W.printEnum("Type", E->e_type, makeArrayRef(ElfObjectFileType));
W.printEnum("Machine", E->e_machine, makeArrayRef(ElfMachineType));
W.printNumber("Version", E->e_version);
W.printHex("Entry", E->e_entry);
W.printHex("ProgramHeaderOffset", E->e_phoff);
W.printHex("SectionHeaderOffset", E->e_shoff);
if (E->e_machine == EM_MIPS)
W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderMipsFlags),
W.printEnum("Type", E.e_type, makeArrayRef(ElfObjectFileType));
W.printEnum("Machine", E.e_machine, makeArrayRef(ElfMachineType));
W.printNumber("Version", E.e_version);
W.printHex("Entry", E.e_entry);
W.printHex("ProgramHeaderOffset", E.e_phoff);
W.printHex("SectionHeaderOffset", E.e_shoff);
if (E.e_machine == EM_MIPS)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderMipsFlags),
unsigned(ELF::EF_MIPS_ARCH), unsigned(ELF::EF_MIPS_ABI),
unsigned(ELF::EF_MIPS_MACH));
else if (E->e_machine == EM_AMDGPU)
W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderAMDGPUFlags),
else if (E.e_machine == EM_AMDGPU)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderAMDGPUFlags),
unsigned(ELF::EF_AMDGPU_MACH));
else if (E->e_machine == EM_RISCV)
W.printFlags("Flags", E->e_flags, makeArrayRef(ElfHeaderRISCVFlags));
else if (E.e_machine == EM_RISCV)
W.printFlags("Flags", E.e_flags, makeArrayRef(ElfHeaderRISCVFlags));
else
W.printFlags("Flags", E->e_flags);
W.printNumber("HeaderSize", E->e_ehsize);
W.printNumber("ProgramHeaderEntrySize", E->e_phentsize);
W.printNumber("ProgramHeaderCount", E->e_phnum);
W.printNumber("SectionHeaderEntrySize", E->e_shentsize);
W.printFlags("Flags", E.e_flags);
W.printNumber("HeaderSize", E.e_ehsize);
W.printNumber("ProgramHeaderEntrySize", E.e_phentsize);
W.printNumber("ProgramHeaderCount", E.e_phnum);
W.printNumber("SectionHeaderEntrySize", E.e_shentsize);
W.printString("SectionHeaderCount",
getSectionHeadersNumString(this->Obj, this->FileName));
W.printString("StringTableSectionIndex",
@ -6133,13 +6131,13 @@ template <class ELFT> void LLVMStyle<ELFT>::printSectionHeaders() {
int SectionIndex = -1;
std::vector<EnumEntry<unsigned>> FlagsList =
getSectionFlagsForTarget(this->Obj.getHeader()->e_machine);
getSectionFlagsForTarget(this->Obj.getHeader().e_machine);
for (const Elf_Shdr &Sec : cantFail(this->Obj.sections())) {
DictScope SectionD(W, "Section");
W.printNumber("Index", ++SectionIndex);
W.printNumber("Name", this->getPrintableSectionName(Sec), Sec.sh_name);
W.printHex("Type",
object::getELFSectionTypeName(this->Obj.getHeader()->e_machine,
object::getELFSectionTypeName(this->Obj.getHeader().e_machine,
Sec.sh_type),
Sec.sh_type);
W.printFlags("Flags", Sec.sh_flags, makeArrayRef(FlagsList));
@ -6167,7 +6165,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printSectionHeaders() {
const Elf_Shdr *SymSec =
unwrapOrError(this->FileName,
this->Obj.getSection(
&Sym, Symtab, this->dumper()->getShndxTable()));
Sym, Symtab, this->dumper()->getShndxTable()));
if (SymSec == &Sec)
printSymbol(&Sym,
unwrapOrError(this->FileName, this->Obj.symbols(Symtab))
@ -6179,7 +6177,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printSectionHeaders() {
if (opts::SectionData && Sec.sh_type != ELF::SHT_NOBITS) {
ArrayRef<uint8_t> Data =
unwrapOrError(this->FileName, this->Obj.getSectionContents(&Sec));
unwrapOrError(this->FileName, this->Obj.getSectionContents(Sec));
W.printBinaryBlock(
"SectionData",
StringRef(reinterpret_cast<const char *>(Data.data()), Data.size()));
@ -6229,7 +6227,7 @@ void LLVMStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
W.printHex("Value", Symbol->st_value);
W.printNumber("Size", Symbol->st_size);
W.printEnum("Binding", Symbol->getBinding(), makeArrayRef(ElfSymbolBindings));
if (this->Obj.getHeader()->e_machine == ELF::EM_AMDGPU &&
if (this->Obj.getHeader().e_machine == ELF::EM_AMDGPU &&
SymbolType >= ELF::STT_LOOS && SymbolType < ELF::STT_HIOS)
W.printEnum("Type", SymbolType, makeArrayRef(AMDGPUSymbolTypes));
else
@ -6241,7 +6239,7 @@ void LLVMStyle<ELFT>::printSymbol(const Elf_Sym *Symbol, const Elf_Sym *First,
else {
std::vector<EnumEntry<unsigned>> SymOtherFlags(std::begin(ElfSymOtherFlags),
std::end(ElfSymOtherFlags));
if (this->Obj.getHeader()->e_machine == EM_MIPS) {
if (this->Obj.getHeader().e_machine == EM_MIPS) {
// Someones in their infinite wisdom decided to make STO_MIPS_MIPS16
// flag overlapped with other ST_MIPS_xxx flags. So consider both
// cases separately.
@ -6342,7 +6340,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printProgramHeaders() {
for (const Elf_Phdr &Phdr : *PhdrsOrErr) {
DictScope P(W, "ProgramHeader");
StringRef Type =
segmentTypeToString(this->Obj.getHeader()->e_machine, Phdr.p_type);
segmentTypeToString(this->Obj.getHeader().e_machine, Phdr.p_type);
W.printHex("Type", Type.empty() ? "Unknown" : Type, Phdr.p_type);
W.printHex("Offset", Phdr.p_offset);
@ -6452,7 +6450,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printCGProfile() {
Expected<ArrayRef<Elf_CGProfile>> CGProfileOrErr =
this->Obj.template getSectionContentsAsArray<Elf_CGProfile>(
this->dumper()->getDotCGProfileSec());
*this->dumper()->getDotCGProfileSec());
if (!CGProfileOrErr) {
this->reportUniqueWarning(
createError("unable to dump the SHT_LLVM_CALL_GRAPH_PROFILE section: " +
@ -6491,7 +6489,8 @@ template <class ELFT> void LLVMStyle<ELFT>::printAddrsig() {
if (!Sec)
return;
Expected<ArrayRef<uint8_t>> ContentsOrErr = this->Obj.getSectionContents(Sec);
Expected<ArrayRef<uint8_t>> ContentsOrErr =
this->Obj.getSectionContents(*Sec);
if (!ContentsOrErr) {
this->reportUniqueWarning(ContentsOrErr.takeError());
return;
@ -6573,7 +6572,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printNotes() {
W.printHex("Data size", Descriptor.size());
StringRef NoteType =
getNoteTypeName<ELFT>(Note, this->Obj.getHeader()->e_type);
getNoteTypeName<ELFT>(Note, this->Obj.getHeader().e_type);
if (!NoteType.empty())
W.printString("Type", NoteType);
else
@ -6609,12 +6608,12 @@ template <class ELFT> void LLVMStyle<ELFT>::printNotes() {
};
ArrayRef<Elf_Shdr> Sections = cantFail(this->Obj.sections());
if (this->Obj.getHeader()->e_type != ELF::ET_CORE && !Sections.empty()) {
for (const auto &S : Sections) {
if (this->Obj.getHeader().e_type != ELF::ET_CORE && !Sections.empty()) {
for (const Elf_Shdr &S : Sections) {
if (S.sh_type != SHT_NOTE)
continue;
DictScope D(W, "NoteSection");
PrintHeader(expectedToOptional(this->Obj.getSectionName(&S)), S.sh_offset,
PrintHeader(expectedToOptional(this->Obj.getSectionName(S)), S.sh_offset,
S.sh_size);
Error Err = Error::success();
for (auto Note : this->Obj.notes(S, Err))
@ -6655,7 +6654,7 @@ template <class ELFT> void LLVMStyle<ELFT>::printELFLinkerOptions() {
continue;
Expected<ArrayRef<uint8_t>> ContentsOrErr =
this->Obj.getSectionContents(&Shdr);
this->Obj.getSectionContents(Shdr);
if (!ContentsOrErr) {
this->reportUniqueWarning(
createError("unable to read the content of the "

70
llvm/tools/obj2yaml/elf2yaml.cpp
View File

@ -124,7 +124,7 @@ ELFDumper<ELFT>::getUniquedSectionName(const Elf_Shdr *Sec) {
if (!SectionNames[SecIndex].empty())
return SectionNames[SecIndex];
auto NameOrErr = Obj.getSectionName(Sec);
auto NameOrErr = Obj.getSectionName(*Sec);
if (!NameOrErr)
return NameOrErr;
StringRef Name = *NameOrErr;
@ -153,7 +153,7 @@ ELFDumper<ELFT>::getUniquedSymbolName(const Elf_Sym *Sym, StringRef StrTable,
return SymbolNameOrErr;
StringRef Name = *SymbolNameOrErr;
if (Name.empty() && Sym->getType() == ELF::STT_SECTION) {
auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
auto ShdrOrErr = Obj.getSection(*Sym, SymTab, ShndxTable);
if (!ShdrOrErr)
return ShdrOrErr.takeError();
return getUniquedSectionName(*ShdrOrErr);
@ -235,14 +235,14 @@ template <class ELFT> Expected<ELFYAML::Object *> ELFDumper<ELFT>::dump() {
// Dump header. We do not dump EPh* and ESh* fields. When not explicitly set,
// the values are set by yaml2obj automatically and there is no need to dump
// them here.
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.ABIVersion = Obj.getHeader()->e_ident[ELF::EI_ABIVERSION];
Y->Header.Type = Obj.getHeader()->e_type;
Y->Header.Machine = ELFYAML::ELF_EM(Obj.getHeader()->e_machine);
Y->Header.Flags = Obj.getHeader()->e_flags;
Y->Header.Entry = Obj.getHeader()->e_entry;
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.ABIVersion = Obj.getHeader().e_ident[ELF::EI_ABIVERSION];
Y->Header.Type = Obj.getHeader().e_type;
Y->Header.Machine = ELFYAML::ELF_EM(Obj.getHeader().e_machine);
Y->Header.Flags = Obj.getHeader().e_flags;
Y->Header.Entry = Obj.getHeader().e_entry;
// Dump sections
auto SectionsOrErr = Obj.sections();
@ -588,7 +588,7 @@ Error ELFDumper<ELFT>::dumpSymbol(const Elf_Sym *Sym, const Elf_Shdr *SymTab,
return Error::success();
}
auto ShdrOrErr = Obj.getSection(Sym, SymTab, ShndxTable);
auto ShdrOrErr = Obj.getSection(*Sym, SymTab, ShndxTable);
if (!ShdrOrErr)
return ShdrOrErr.takeError();
const Elf_Shdr *Shdr = *ShdrOrErr;
@ -611,7 +611,7 @@ Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
R.Offset = Rel->r_offset;
R.Addend = 0;
auto SymOrErr = Obj.getRelocationSymbol(Rel, SymTab);
auto SymOrErr = Obj.getRelocationSymbol(*Rel, SymTab);
if (!SymOrErr)
return SymOrErr.takeError();
@ -624,7 +624,7 @@ Error ELFDumper<ELFT>::dumpRelocation(const RelT *Rel, const Elf_Shdr *SymTab,
auto StrTabSec = Obj.getSection(SymTab->sh_link);
if (!StrTabSec)
return StrTabSec.takeError();
auto StrTabOrErr = Obj.getStringTable(*StrTabSec);
auto StrTabOrErr = Obj.getStringTable(**StrTabSec);
if (!StrTabOrErr)
return StrTabOrErr.takeError();
@ -725,7 +725,7 @@ ELFDumper<ELFT>::dumpStackSizesSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -758,7 +758,7 @@ ELFDumper<ELFT>::dumpAddrsigSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -799,7 +799,7 @@ ELFDumper<ELFT>::dumpLinkerOptionsSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -830,7 +830,7 @@ ELFDumper<ELFT>::dumpDependentLibrariesSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *DL))
return std::move(E);
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -857,7 +857,7 @@ ELFDumper<ELFT>::dumpCallGraphProfileSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
ArrayRef<uint8_t> Content = *ContentOrErr;
@ -913,7 +913,7 @@ ELFDumper<ELFT>::dumpDynamicSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(Shdr);
auto DynTagsOrErr = Obj.template getSectionContentsAsArray<Elf_Dyn>(*Shdr);
if (!DynTagsOrErr)
return DynTagsOrErr.takeError();
@ -936,7 +936,7 @@ ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
const Elf_Shdr *SymTab = *SymTabOrErr;
if (Shdr->sh_type == ELF::SHT_REL) {
auto Rels = Obj.rels(Shdr);
auto Rels = Obj.rels(*Shdr);
if (!Rels)
return Rels.takeError();
for (const Elf_Rel &Rel : *Rels) {
@ -946,7 +946,7 @@ ELFDumper<ELFT>::dumpRelocSection(const Elf_Shdr *Shdr) {
S->Relocations.push_back(R);
}
} else {
auto Rels = Obj.relas(Shdr);
auto Rels = Obj.relas(*Shdr);
if (!Rels)
return Rels.takeError();
for (const Elf_Rela &Rel : *Rels) {
@ -968,7 +968,7 @@ ELFDumper<ELFT>::dumpRelrSection(const Elf_Shdr *Shdr) {
if (auto E = dumpCommonSection(Shdr, *S))
return std::move(E);
if (Expected<ArrayRef<Elf_Relr>> Relrs = Obj.relrs(Shdr)) {
if (Expected<ArrayRef<Elf_Relr>> Relrs = Obj.relrs(*Shdr)) {
S->Entries.emplace();
for (Elf_Relr Rel : *Relrs)
S->Entries->emplace_back(Rel);
@ -978,7 +978,7 @@ ELFDumper<ELFT>::dumpRelrSection(const Elf_Shdr *Shdr) {
consumeError(Relrs.takeError());
}
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(Shdr);
Expected<ArrayRef<uint8_t>> ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
S->Content = *ContentOrErr;
@ -994,7 +994,7 @@ ELFDumper<ELFT>::dumpContentSection(const Elf_Shdr *Shdr) {
unsigned SecIndex = Shdr - &Sections[0];
if (SecIndex != 0 || Shdr->sh_type != ELF::SHT_NULL) {
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
ArrayRef<uint8_t> Content = *ContentOrErr;
@ -1016,7 +1016,7 @@ ELFDumper<ELFT>::dumpSymtabShndxSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto EntriesOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
auto EntriesOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
if (!EntriesOrErr)
return EntriesOrErr.takeError();
for (const Elf_Word &E : *EntriesOrErr)
@ -1042,7 +1042,7 @@ ELFDumper<ELFT>::dumpNoteSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -1078,7 +1078,7 @@ ELFDumper<ELFT>::dumpHashSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -1119,7 +1119,7 @@ ELFDumper<ELFT>::dumpGnuHashSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();
@ -1179,11 +1179,11 @@ ELFDumper<ELFT>::dumpVerdefSection(const Elf_Shdr *Shdr) {
if (!StringTableShdrOrErr)
return StringTableShdrOrErr.takeError();
auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
auto StringTableOrErr = Obj.getStringTable(**StringTableShdrOrErr);
if (!StringTableOrErr)
return StringTableOrErr.takeError();
auto Contents = Obj.getSectionContents(Shdr);
auto Contents = Obj.getSectionContents(*Shdr);
if (!Contents)
return Contents.takeError();
@ -1224,7 +1224,7 @@ ELFDumper<ELFT>::dumpSymverSection(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(Shdr);
auto VersionsOrErr = Obj.template getSectionContentsAsArray<Elf_Half>(*Shdr);
if (!VersionsOrErr)
return VersionsOrErr.takeError();
for (const Elf_Half &E : *VersionsOrErr)
@ -1245,7 +1245,7 @@ ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
S->Info = Shdr->sh_info;
auto Contents = Obj.getSectionContents(Shdr);
auto Contents = Obj.getSectionContents(*Shdr);
if (!Contents)
return Contents.takeError();
@ -1253,7 +1253,7 @@ ELFDumper<ELFT>::dumpVerneedSection(const Elf_Shdr *Shdr) {
if (!StringTableShdrOrErr)
return StringTableShdrOrErr.takeError();
auto StringTableOrErr = Obj.getStringTable(*StringTableShdrOrErr);
auto StringTableOrErr = Obj.getStringTable(**StringTableShdrOrErr);
if (!StringTableOrErr)
return StringTableOrErr.takeError();
@ -1322,7 +1322,7 @@ Expected<ELFYAML::Group *> ELFDumper<ELFT>::dumpGroup(const Elf_Shdr *Shdr) {
return SymbolName.takeError();
S->Signature = *SymbolName;
auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(Shdr);
auto MembersOrErr = Obj.template getSectionContentsAsArray<Elf_Word>(*Shdr);
if (!MembersOrErr)
return MembersOrErr.takeError();
@ -1352,7 +1352,7 @@ ELFDumper<ELFT>::dumpMipsABIFlags(const Elf_Shdr *Shdr) {
if (Error E = dumpCommonSection(Shdr, *S))
return std::move(E);
auto ContentOrErr = Obj.getSectionContents(Shdr);
auto ContentOrErr = Obj.getSectionContents(*Shdr);
if (!ContentOrErr)
return ContentOrErr.takeError();