13#ifndef LLVM_OBJECT_ELF_H
14#define LLVM_OBJECT_ELF_H
76inline std::pair<unsigned char, unsigned char>
95template <
class ELFT>
class ELFFile;
112 "the index is greater than or equal to the number of entries (" +
115 const uint8_t *EntryStart = (
const uint8_t *)
First +
N *
sizeof(
T);
116 if (EntryStart +
sizeof(
T) >
BufEnd)
117 return createError(
"can't read past the end of the file");
129 const typename ELFT::Shdr &Sec) {
132 return "[index " + std::to_string(&Sec - &TableOrErr->front()) +
"]";
138 return "[unknown index]";
143 const typename ELFT::Shdr &Sec) {
147 " section with index " +
Twine(SecNdx))
153 const typename ELFT::Phdr &Phdr) {
156 return (
"[index " +
Twine(&Phdr - &Headers->front()) +
"]").str();
159 return "[unknown index]";
168 const typename ELFT::Shdr &Sec) {
173 if (Sec.sh_offset < Phdr.p_offset)
177 if (Sec.sh_size == 0)
178 return (Sec.sh_offset + 1 <= Phdr.p_offset + Phdr.p_filesz);
179 return Sec.sh_offset + Sec.sh_size <= Phdr.p_offset + Phdr.p_filesz;
186 const typename ELFT::Shdr &Sec) {
190 if (Sec.sh_addr < Phdr.p_vaddr)
196 bool IsTbssInNonTLS = IsTbss && Phdr.p_type !=
ELF::PT_TLS;
198 if (Sec.sh_size == 0 || IsTbssInNonTLS)
199 return Sec.sh_addr + 1 <= Phdr.p_vaddr + Phdr.p_memsz;
200 return Sec.sh_addr + Sec.sh_size <= Phdr.p_vaddr + Phdr.p_memsz;
205 const typename ELFT::Shdr &Sec) {
206 return checkSectionOffsets<ELFT>(Phdr, Sec) &&
207 checkSectionVMA<ELFT>(Phdr, Sec);
229 std::vector<Elf_Shdr> FakeSections;
236 return *
reinterpret_cast<const Elf_Ehdr *
>(
base());
239 template <
typename T>
241 template <
typename T>
250 uint32_t SymbolVersionIndex,
bool &IsDefault,
251 SmallVector<std::optional<VersionEntry>, 0> &VersionMap,
252 std::optional<bool> IsSymHidden)
const;
259 Elf_Shdr_Range Sections)
const;
264 Elf_Shdr_Range Sections)
const;
278 const Elf_Shdr *SymTab)
const;
281 loadVersionMap(
const Elf_Shdr *VerNeedSec,
const Elf_Shdr *VerDefSec)
const;
307 return getSectionContentsAsArray<Elf_Sym>(*Sec);
311 return getSectionContentsAsArray<Elf_Rela>(Sec);
315 return getSectionContentsAsArray<Elf_Rel>(Sec);
319 return getSectionContentsAsArray<Elf_Relr>(Sec);
335 if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize >
getBufSize())
336 return createError(
"program headers are longer than binary of size " +
342 auto *Begin =
reinterpret_cast<const Elf_Phdr *
>(
base() + PhOff);
356 if (Phdr.p_offset + Phdr.p_filesz >
getBufSize()) {
360 return Elf_Note_Iterator(Err);
364 if (Phdr.p_align != 0 && Phdr.p_align != 1 && Phdr.p_align != 4 &&
368 return Elf_Note_Iterator(Err);
370 return Elf_Note_Iterator(
base() + Phdr.p_offset, Phdr.p_filesz,
371 std::max<size_t>(Phdr.p_align, 4), Err);
388 return Elf_Note_Iterator(Err);
391 if (
Shdr.sh_addralign != 0 &&
Shdr.sh_addralign != 1 &&
392 Shdr.sh_addralign != 4 &&
Shdr.sh_addralign != 8) {
395 return Elf_Note_Iterator(Err);
397 return Elf_Note_Iterator(
base() +
Shdr.sh_offset,
Shdr.sh_size,
398 std::max<size_t>(
Shdr.sh_addralign, 4), Err);
403 return Elf_Note_Iterator();
431 Elf_Shdr_Range Sections,
436 const Elf_Shdr *SymTab,
439 Elf_Sym_Range Symtab,
451 template <
typename T>
461 decodeBBAddrMap(
const Elf_Shdr &Sec,
const Elf_Shdr *RelaSec =
nullptr)
const;
482 if (
Index >= Sections.size())
484 return &Sections[
Index];
492 if (!ShndxTable.
First)
494 "found an extended symbol index (" +
Twine(SymIndex) +
495 "), but unable to locate the extended symbol index table");
499 return createError(
"unable to read an extended symbol table at index " +
500 Twine(SymIndex) +
": " +
512 getExtendedSymbolTableIndex<ELFT>(
Sym, &
Sym - Syms.begin(), ShndxTable);
515 return *ErrorOrIndex;
526 auto SymsOrErr = symbols(SymTab);
528 return SymsOrErr.takeError();
536 auto IndexOrErr = getSectionIndex(
Sym, Symbols, ShndxTable);
538 return IndexOrErr.takeError();
548 auto SymsOrErr = symbols(Sec);
550 return SymsOrErr.takeError();
552 Elf_Sym_Range Symbols = *SymsOrErr;
553 if (
Index >= Symbols.size())
554 return createError(
"unable to get symbol from section " +
556 ": invalid symbol index (" +
Twine(
Index) +
")");
557 return &Symbols[
Index];
564 if (Sec.sh_entsize !=
sizeof(
T) &&
sizeof(
T) != 1)
566 " has invalid sh_entsize: expected " +
Twine(
sizeof(
T)) +
567 ", but got " +
Twine(Sec.sh_entsize));
569 uintX_t
Offset = Sec.sh_offset;
570 uintX_t
Size = Sec.sh_size;
572 if (
Size %
sizeof(
T))
574 " has an invalid sh_size (" +
Twine(
Size) +
575 ") which is not a multiple of its sh_entsize (" +
576 Twine(Sec.sh_entsize) +
")");
577 if (std::numeric_limits<uintX_t>::max() -
Offset <
Size)
581 ") that cannot be represented");
586 ") that is greater than the file size (0x" +
593 const T *Start =
reinterpret_cast<const T *
>(base() +
Offset);
600 uintX_t
Offset = Phdr.p_offset;
601 uintX_t
Size = Phdr.p_filesz;
603 if (std::numeric_limits<uintX_t>::max() -
Offset <
Size)
607 ") that cannot be represented");
612 ") that is greater than the file size (0x" +
620 return getSectionContentsAsArray<uint8_t>(Sec);
631 if (!isMipsELF64()) {
633 Result.append(
Name.begin(),
Name.end());
641 uint8_t Type1 = (
Type >> 0) & 0xFF;
647 Result.append(
Name.begin(),
Name.end());
650 Result.append(1,
'/');
651 Result.append(
Name.begin(),
Name.end());
654 Result.append(1,
'/');
655 Result.append(
Name.begin(),
Name.end());
667 const Elf_Shdr *VerDefSec)
const {
675 auto InsertEntry = [&](
unsigned N,
StringRef Version,
bool IsVerdef) {
676 if (
N >= VersionMap.
size())
678 VersionMap[
N] = {std::string(Version), IsVerdef};
685 for (
const VerDef &Def : *Defs)
693 for (
const VerNeed &Dep : *Deps)
694 for (
const VernAux &Aux : Dep.AuxV)
704 const Elf_Shdr *SymTab)
const {
708 return getEntry<Elf_Sym>(*SymTab,
Index);
721 if (Sections.empty())
723 "e_shstrndx == SHN_XINDEX, but the section header table is empty");
725 Index = Sections[0].sh_link;
731 return FakeSectionStrings;
733 if (
Index >= Sections.size())
736 return getStringTable(Sections[
Index], WarnHandler);
745 const void *BufEnd) {
746 using Elf_Word =
typename ELFT::Word;
747 if (Table.nbuckets == 0)
748 return Table.symndx + 1;
751 for (Elf_Word Val : Table.buckets())
752 LastSymIdx = std::max(LastSymIdx, (
uint64_t)Val);
754 reinterpret_cast<const Elf_Word *
>(Table.values(LastSymIdx).end());
756 while (It < BufEnd && (*It & 1) == 0) {
763 "no terminator found for GNU hash section before buffer end");
765 return LastSymIdx + 1;
775 if (!SectionsOrError)
777 for (
const Elf_Shdr &Sec : *SectionsOrError) {
779 if (Sec.sh_size % Sec.sh_entsize != 0) {
781 "SHT_DYNSYM section has sh_size (" +
782 Twine(Sec.sh_size) +
") % sh_entsize (" +
783 Twine(Sec.sh_entsize) +
") that is not 0");
785 return Sec.sh_size / Sec.sh_entsize;
789 if (!SectionsOrError->empty()) {
800 std::optional<uint64_t> ElfHash;
801 std::optional<uint64_t> ElfGnuHash;
802 for (
const Elf_Dyn &Entry : *DynTable) {
803 switch (Entry.d_tag) {
805 ElfHash = Entry.d_un.d_ptr;
807 case ELF::DT_GNU_HASH:
808 ElfGnuHash = Entry.d_un.d_ptr;
816 const Elf_GnuHash *Table =
817 reinterpret_cast<const Elf_GnuHash *
>(TablePtr.
get());
818 return getDynSymtabSizeFromGnuHash<ELFT>(*Table, this->Buf.
bytes_end());
826 const Elf_Hash *Table =
reinterpret_cast<const Elf_Hash *
>(TablePtr.
get());
827 return Table->nchain;
836 if (
sizeof(Elf_Ehdr) > Object.size())
838 ") is smaller than an ELF header (" +
839 Twine(
sizeof(Elf_Ehdr)) +
")");
847 if (!FakeSections.empty())
849 auto PhdrsOrErr = program_headers();
853 FakeSectionStrings +=
'\0';
857 Elf_Shdr FakeShdr = {};
860 FakeShdr.sh_addr = Phdr.p_vaddr;
861 FakeShdr.sh_size = Phdr.p_memsz;
862 FakeShdr.sh_offset = Phdr.p_offset;
864 FakeShdr.sh_name = FakeSectionStrings.
size();
865 FakeSectionStrings += (
"PT_LOAD#" +
Twine(
Idx)).str();
866 FakeSectionStrings +=
'\0';
873 const uintX_t SectionTableOffset = getHeader().e_shoff;
874 if (SectionTableOffset == 0) {
875 if (!FakeSections.empty())
876 return ArrayRef(FakeSections.data(), FakeSections.size());
880 if (getHeader().e_shentsize !=
sizeof(Elf_Shdr))
881 return createError(
"invalid e_shentsize in ELF header: " +
882 Twine(getHeader().e_shentsize));
885 if (SectionTableOffset +
sizeof(Elf_Shdr) > FileSize ||
886 SectionTableOffset + (uintX_t)
sizeof(Elf_Shdr) < SectionTableOffset)
888 "section header table goes past the end of the file: e_shoff = 0x" +
892 if (SectionTableOffset & (
alignof(Elf_Shdr) - 1))
894 return createError(
"invalid alignment of section headers");
896 const Elf_Shdr *
First =
897 reinterpret_cast<const Elf_Shdr *
>(base() + SectionTableOffset);
899 uintX_t NumSections = getHeader().e_shnum;
900 if (NumSections == 0)
901 NumSections =
First->sh_size;
903 if (NumSections >
UINT64_MAX /
sizeof(Elf_Shdr))
904 return createError(
"invalid number of sections specified in the NULL "
905 "section's sh_size field (" +
906 Twine(NumSections) +
")");
908 const uint64_t SectionTableSize = NumSections *
sizeof(Elf_Shdr);
909 if (SectionTableOffset + SectionTableSize < SectionTableOffset)
911 "invalid section header table offset (e_shoff = 0x" +
913 ") or invalid number of sections specified in the first section "
914 "header's sh_size field (0x" +
918 if (SectionTableOffset + SectionTableSize > FileSize)
919 return createError(
"section table goes past the end of file");
929 return SecOrErr.takeError();
930 return getEntry<T>(**SecOrErr, Entry);
942 if (Entry >= Arr.
size())
944 "can't read an entry at 0x" +
946 ": it goes past the end of the section (0x" +
951template <
typename ELFT>
953 uint32_t SymbolVersionIndex,
bool &IsDefault,
954 SmallVector<std::optional<VersionEntry>, 0> &VersionMap,
955 std::optional<bool> IsSymHidden)
const {
966 if (VersionIndex >= VersionMap.size() || !VersionMap[VersionIndex])
967 return createError(
"SHT_GNU_versym section refers to a version index " +
968 Twine(VersionIndex) +
" which is missing");
972 if (!Entry.IsVerDef || IsSymHidden.value_or(
false))
976 return Entry.Name.c_str();
991 const uint8_t *Start = ContentsOrErr->data();
992 const uint8_t *
End = Start + ContentsOrErr->size();
994 auto ExtractNextAux = [&](
const uint8_t *&VerdauxBuf,
996 if (VerdauxBuf +
sizeof(Elf_Verdaux) >
End)
998 ": version definition " +
Twine(VerDefNdx) +
999 " refers to an auxiliary entry that goes past the end "
1002 auto *Verdaux =
reinterpret_cast<const Elf_Verdaux *
>(VerdauxBuf);
1003 VerdauxBuf += Verdaux->vda_next;
1006 Aux.
Offset = VerdauxBuf - Start;
1007 if (Verdaux->vda_name <= StrTabOrErr->size())
1008 Aux.
Name = std::string(StrTabOrErr->drop_front(Verdaux->vda_name));
1010 Aux.
Name = (
"<invalid vda_name: " +
Twine(Verdaux->vda_name) +
">").str();
1014 std::vector<VerDef> Ret;
1015 const uint8_t *VerdefBuf = Start;
1016 for (
unsigned I = 1;
I <= Sec.sh_info; ++
I) {
1017 if (VerdefBuf +
sizeof(Elf_Verdef) >
End)
1019 ": version definition " +
Twine(
I) +
1020 " goes past the end of the section");
1022 if (
reinterpret_cast<uintptr_t
>(VerdefBuf) %
sizeof(
uint32_t) != 0)
1024 "invalid " +
describe(*
this, Sec) +
1025 ": found a misaligned version definition entry at offset 0x" +
1028 unsigned Version = *
reinterpret_cast<const Elf_Half *
>(VerdefBuf);
1031 ": version " +
Twine(Version) +
1032 " is not yet supported");
1034 const Elf_Verdef *
D =
reinterpret_cast<const Elf_Verdef *
>(VerdefBuf);
1035 VerDef &VD = *Ret.emplace(Ret.end());
1036 VD.
Offset = VerdefBuf - Start;
1041 VD.
Hash =
D->vd_hash;
1043 const uint8_t *VerdauxBuf = VerdefBuf +
D->vd_aux;
1044 for (
unsigned J = 0; J <
D->vd_cnt; ++J) {
1045 if (
reinterpret_cast<uintptr_t
>(VerdauxBuf) %
sizeof(
uint32_t) != 0)
1047 ": found a misaligned auxiliary entry at offset 0x" +
1055 VD.
Name = AuxOrErr->Name;
1057 VD.
AuxV.push_back(*AuxOrErr);
1060 VerdefBuf +=
D->vd_next;
1066template <
class ELFT>
1074 return std::move(
E);
1076 StrTab = *StrTabOrErr;
1084 const uint8_t *Start = ContentsOrErr->data();
1085 const uint8_t *
End = Start + ContentsOrErr->size();
1086 const uint8_t *VerneedBuf = Start;
1088 std::vector<VerNeed> Ret;
1089 for (
unsigned I = 1;
I <= Sec.sh_info; ++
I) {
1090 if (VerneedBuf +
sizeof(Elf_Verdef) >
End)
1092 ": version dependency " +
Twine(
I) +
1093 " goes past the end of the section");
1095 if (
reinterpret_cast<uintptr_t
>(VerneedBuf) %
sizeof(
uint32_t) != 0)
1097 "invalid " +
describe(*
this, Sec) +
1098 ": found a misaligned version dependency entry at offset 0x" +
1101 unsigned Version = *
reinterpret_cast<const Elf_Half *
>(VerneedBuf);
1104 ": version " +
Twine(Version) +
1105 " is not yet supported");
1107 const Elf_Verneed *Verneed =
1108 reinterpret_cast<const Elf_Verneed *
>(VerneedBuf);
1110 VerNeed &VN = *Ret.emplace(Ret.end());
1111 VN.
Version = Verneed->vn_version;
1112 VN.
Cnt = Verneed->vn_cnt;
1113 VN.
Offset = VerneedBuf - Start;
1115 if (Verneed->vn_file < StrTab.
size())
1116 VN.
File = std::string(StrTab.
data() + Verneed->vn_file);
1118 VN.
File = (
"<corrupt vn_file: " +
Twine(Verneed->vn_file) +
">").str();
1120 const uint8_t *VernauxBuf = VerneedBuf + Verneed->vn_aux;
1121 for (
unsigned J = 0; J < Verneed->vn_cnt; ++J) {
1122 if (
reinterpret_cast<uintptr_t
>(VernauxBuf) %
sizeof(
uint32_t) != 0)
1124 ": found a misaligned auxiliary entry at offset 0x" +
1127 if (VernauxBuf +
sizeof(Elf_Vernaux) >
End)
1129 "invalid " +
describe(*
this, Sec) +
": version dependency " +
1131 " refers to an auxiliary entry that goes past the end "
1134 const Elf_Vernaux *Vernaux =
1135 reinterpret_cast<const Elf_Vernaux *
>(VernauxBuf);
1138 Aux.
Hash = Vernaux->vna_hash;
1139 Aux.
Flags = Vernaux->vna_flags;
1140 Aux.
Other = Vernaux->vna_other;
1141 Aux.
Offset = VernauxBuf - Start;
1142 if (StrTab.
size() <= Vernaux->vna_name)
1143 Aux.
Name =
"<corrupt>";
1147 VernauxBuf += Vernaux->vna_next;
1149 VerneedBuf += Verneed->vn_next;
1154template <
class ELFT>
1159 return TableOrErr.takeError();
1160 return object::getSection<ELFT>(*TableOrErr,
Index);
1163template <
class ELFT>
1168 if (
Error E = WarnHandler(
"invalid sh_type for string table section " +
1170 ": expected SHT_STRTAB, but got " +
1172 getHeader().e_machine, Section.sh_type)))
1173 return std::move(
E);
1175 auto V = getSectionContentsAsArray<char>(Section);
1177 return V.takeError();
1180 return createError(
"SHT_STRTAB string table section " +
1182 if (
Data.back() !=
'\0')
1183 return createError(
"SHT_STRTAB string table section " +
1185 " is non-null terminated");
1189template <
class ELFT>
1194 return SectionsOrErr.takeError();
1195 return getSHNDXTable(Section, *SectionsOrErr);
1198template <
class ELFT>
1201 Elf_Shdr_Range Sections)
const {
1203 auto VOrErr = getSectionContentsAsArray<Elf_Word>(Section);
1205 return VOrErr.takeError();
1207 auto SymTableOrErr = object::getSection<ELFT>(Sections, Section.sh_link);
1209 return SymTableOrErr.takeError();
1210 const Elf_Shdr &SymTable = **SymTableOrErr;
1214 "SHT_SYMTAB_SHNDX section is linked with " +
1216 " section (expected SHT_SYMTAB/SHT_DYNSYM)");
1218 uint64_t Syms = SymTable.sh_size /
sizeof(Elf_Sym);
1219 if (V.size() != Syms)
1221 " entries, but the symbol table associated has " +
1227template <
class ELFT>
1232 return SectionsOrErr.takeError();
1233 return getStringTableForSymtab(Sec, *SectionsOrErr);
1236template <
class ELFT>
1239 Elf_Shdr_Range Sections)
const {
1243 "invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
1245 object::getSection<ELFT>(Sections, Sec.sh_link);
1248 return getStringTable(**SectionOrErr);
1251template <
class ELFT>
1256 if (!StrTabSecOrErr)
1262 return createError(
"invalid string table linked to " +
1265 return *StrTabOrErr;
1268template <
class ELFT>
1274 return SectionsOrErr.takeError();
1275 auto Table = getSectionStringTable(*SectionsOrErr, WarnHandler);
1277 return Table.takeError();
1278 return getSectionName(Section, *Table);
1281template <
class ELFT>
1289 " has an invalid sh_name (0x" +
1291 ") offset which goes past the end of the "
1292 "section name string table");
1301 for (uint8_t
C : SymbolName) {
1303 H ^= (
H >> 24) & 0xf0;
1305 return H & 0x0fffffff;
1313 for (uint8_t
C :
Name)
1314 H = (
H << 5) +
H +
C;
bbsections Prepares for basic block sections
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx
static bool isMips64EL(const ELFYAML::Object &Obj)
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
This file implements a map that provides insertion order iteration.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
size - Get the array size.
Helper for Errors used as out-parameters.
Lightweight error class with error context and mandatory checking.
Tagged union holding either a T or a Error.
Error takeError()
Take ownership of the stored error.
reference get()
Returns a reference to the stored T value.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
const unsigned char * bytes_end() const
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
constexpr size_t size() const
size - Get the string size.
const unsigned char * bytes_begin() const
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
static Twine utohexstr(const uint64_t &Val)
The instances of the Type class are immutable: once they are created, they are never changed.
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
const Elf_Ehdr & getHeader() const
Expected< std::vector< Elf_Rela > > android_relas(const Elf_Shdr &Sec) const
Expected< StringRef > getLinkAsStrtab(const typename ELFT::Shdr &Sec) const
static Expected< ELFFile > create(StringRef Object)
Expected< const Elf_Sym * > getSymbol(const Elf_Shdr *Sec, uint32_t Index) const
Expected< std::vector< VerDef > > getVersionDefinitions(const Elf_Shdr &Sec) const
std::string getDynamicTagAsString(unsigned Arch, uint64_t Type) const
Expected< ArrayRef< Elf_Word > > getSHNDXTable(const Elf_Shdr &Section) const
Expected< Elf_Sym_Range > symbols(const Elf_Shdr *Sec) const
Expected< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec, const Elf_Shdr *RelaSec=nullptr) const
Returns a vector of BBAddrMap structs corresponding to each function within the text section that the...
Expected< ArrayRef< uint8_t > > getSegmentContents(const Elf_Phdr &Phdr) const
Elf_Note_Iterator notes_begin(const Elf_Shdr &Shdr, Error &Err) const
Get an iterator over notes in a section.
uint32_t getRelativeRelocationType() const
iterator_range< Elf_Note_Iterator > notes(const Elf_Phdr &Phdr, Error &Err) const
Get an iterator range over notes of a program header.
Expected< StringRef > getSymbolVersionByIndex(uint32_t SymbolVersionIndex, bool &IsDefault, SmallVector< std::optional< VersionEntry >, 0 > &VersionMap, std::optional< bool > IsSymHidden) const
Elf_Note_Iterator notes_begin(const Elf_Phdr &Phdr, Error &Err) const
Get an iterator over notes in a program header.
Expected< ArrayRef< uint8_t > > getSectionContents(const Elf_Shdr &Sec) const
Expected< Elf_Rela_Range > relas(const Elf_Shdr &Sec) const
Expected< Elf_Phdr_Range > program_headers() const
Iterate over program header table.
Expected< StringRef > getStringTableForSymtab(const Elf_Shdr &Section) const
Expected< std::vector< VerNeed > > getVersionDependencies(const Elf_Shdr &Sec, WarningHandler WarnHandler=&defaultWarningHandler) const
size_t getBufSize() const
Expected< const T * > getEntry(uint32_t Section, uint32_t Entry) const
Expected< const Elf_Sym * > getRelocationSymbol(const Elf_Rel &Rel, const Elf_Shdr *SymTab) const
Get the symbol for a given relocation.
const uint8_t * end() const
Expected< StringRef > getSectionStringTable(Elf_Shdr_Range Sections, WarningHandler WarnHandler=&defaultWarningHandler) const
Expected< uint64_t > getDynSymtabSize() const
This function determines the number of dynamic symbols.
Expected< Elf_Dyn_Range > dynamicEntries() const
void createFakeSections()
Used by llvm-objdump -d (which needs sections for disassembly) to disassemble objects without a secti...
Expected< Elf_Shdr_Range > sections() const
iterator_range< Elf_Note_Iterator > notes(const Elf_Shdr &Shdr, Error &Err) const
Get an iterator range over notes of a section.
const uint8_t * base() const
Expected< const uint8_t * > toMappedAddr(uint64_t VAddr, WarningHandler WarnHandler=&defaultWarningHandler) const
Expected< Elf_Relr_Range > relrs(const Elf_Shdr &Sec) const
Expected< MapVector< const Elf_Shdr *, const Elf_Shdr * > > getSectionAndRelocations(std::function< Expected< bool >(const Elf_Shdr &)> IsMatch) const
Returns a map from every section matching IsMatch to its relocation section, or nullptr if it has no ...
Elf_Note_Iterator notes_end() const
Get the end iterator for notes.
Expected< StringRef > getSectionName(const Elf_Shdr &Section, WarningHandler WarnHandler=&defaultWarningHandler) const
StringRef getRelocationTypeName(uint32_t Type) const
Expected< StringRef > getStringTable(const Elf_Shdr &Section, WarningHandler WarnHandler=&defaultWarningHandler) const
llvm::function_ref< Error(const Twine &Msg)> WarningHandler
Expected< ArrayRef< T > > getSectionContentsAsArray(const Elf_Shdr &Sec) const
Expected< SmallVector< std::optional< VersionEntry >, 0 > > loadVersionMap(const Elf_Shdr *VerNeedSec, const Elf_Shdr *VerDefSec) const
Expected< Elf_Rel_Range > rels(const Elf_Shdr &Sec) const
Expected< const Elf_Shdr * > getSection(const Elf_Sym &Sym, const Elf_Shdr *SymTab, DataRegion< Elf_Word > ShndxTable) const
std::vector< Elf_Rel > decode_relrs(Elf_Relr_Range relrs) const
Expected< uint32_t > getSectionIndex(const Elf_Sym &Sym, Elf_Sym_Range Syms, DataRegion< Elf_Word > ShndxTable) const
@ C
The default llvm calling convention, compatible with C.
std::optional< const char * > toString(const std::optional< DWARFFormValue > &V)
Take an optional DWARFFormValue and try to extract a string value from it.
Expected< uint32_t > getExtendedSymbolTableIndex(const typename ELFT::Sym &Sym, unsigned SymIndex, DataRegion< typename ELFT::Word > ShndxTable)
Expected< const typename ELFT::Shdr * > getSection(typename ELFT::ShdrRange Sections, uint32_t Index)
Error createError(const Twine &Err)
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type)
static Expected< uint64_t > getDynSymtabSizeFromGnuHash(const typename ELFT::GnuHash &Table, const void *BufEnd)
This function finds the number of dynamic symbols using a GNU hash table.
bool checkSectionOffsets(const typename ELFT::Phdr &Phdr, const typename ELFT::Shdr &Sec)
uint32_t getELFRelativeRelocationType(uint32_t Machine)
static std::string describe(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
std::string getPhdrIndexForError(const ELFFile< ELFT > &Obj, const typename ELFT::Phdr &Phdr)
uint32_t hashGnu(StringRef Name)
This function returns the hash value for a symbol in the .dynsym section for the GNU hash table.
StringRef getELFSectionTypeName(uint32_t Machine, uint32_t Type)
@ ADDIS_R12_TO_R2_NO_DISP
@ ADDI_R12_TO_R12_NO_DISP
std::pair< unsigned char, unsigned char > getElfArchType(StringRef Object)
static Error defaultWarningHandler(const Twine &Msg)
bool isSectionInSegment(const typename ELFT::Phdr &Phdr, const typename ELFT::Shdr &Sec)
bool checkSectionVMA(const typename ELFT::Phdr &Phdr, const typename ELFT::Shdr &Sec)
std::string getSecIndexForError(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
uint32_t hashSysV(StringRef SymbolName)
This function returns the hash value for a symbol in the .dynsym section Name of the API remains cons...
This is an optimization pass for GlobalISel generic memory operations.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
auto enumerate(FirstRange &&First, RestRanges &&...Rest)
Given two or more input ranges, returns a new range whose values are are tuples (A,...
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
void consumeError(Error Err)
Consume a Error without doing anything.
Expected< T > operator[](uint64_t N)
DataRegion(const T *Data, const uint8_t *BufferEnd)
DataRegion(ArrayRef< T > Arr)
std::optional< uint64_t > Size
std::vector< VerdAux > AuxV
std::vector< VernAux > AuxV