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]";
185 std::vector<Elf_Shdr> FakeSections;
192 return *
reinterpret_cast<const Elf_Ehdr *
>(
base());
195 template <
typename T>
197 template <
typename T>
206 uint32_t SymbolVersionIndex,
bool &IsDefault,
207 SmallVector<std::optional<VersionEntry>, 0> &VersionMap,
208 std::optional<bool> IsSymHidden)
const;
215 Elf_Shdr_Range Sections)
const;
220 Elf_Shdr_Range Sections)
const;
234 const Elf_Shdr *SymTab)
const;
237 loadVersionMap(
const Elf_Shdr *VerNeedSec,
const Elf_Shdr *VerDefSec)
const;
263 return getSectionContentsAsArray<Elf_Sym>(*Sec);
267 return getSectionContentsAsArray<Elf_Rela>(Sec);
271 return getSectionContentsAsArray<Elf_Rel>(Sec);
275 return getSectionContentsAsArray<Elf_Relr>(Sec);
291 if (PhOff + HeadersSize < PhOff || PhOff + HeadersSize >
getBufSize())
292 return createError(
"program headers are longer than binary of size " +
298 auto *Begin =
reinterpret_cast<const Elf_Phdr *
>(
base() + PhOff);
312 if (Phdr.p_offset + Phdr.p_filesz >
getBufSize()) {
316 return Elf_Note_Iterator(Err);
318 return Elf_Note_Iterator(
base() + Phdr.p_offset, Phdr.p_filesz, Err);
335 return Elf_Note_Iterator(Err);
337 return Elf_Note_Iterator(
base() +
Shdr.sh_offset,
Shdr.sh_size, Err);
342 return Elf_Note_Iterator();
370 Elf_Shdr_Range Sections,
375 const Elf_Shdr *SymTab,
378 Elf_Sym_Range Symtab,
390 template <
typename T>
407 if (
Index >= Sections.size())
409 return &Sections[
Index];
417 if (!ShndxTable.
First)
419 "found an extended symbol index (" +
Twine(SymIndex) +
420 "), but unable to locate the extended symbol index table");
424 return createError(
"unable to read an extended symbol table at index " +
425 Twine(SymIndex) +
": " +
437 getExtendedSymbolTableIndex<ELFT>(Sym, &Sym - Syms.begin(), ShndxTable);
440 return *ErrorOrIndex;
451 auto SymsOrErr = symbols(SymTab);
453 return SymsOrErr.takeError();
454 return getSection(Sym, *SymsOrErr, ShndxTable);
461 auto IndexOrErr = getSectionIndex(Sym, Symbols, ShndxTable);
463 return IndexOrErr.takeError();
473 auto SymsOrErr = symbols(Sec);
475 return SymsOrErr.takeError();
477 Elf_Sym_Range Symbols = *SymsOrErr;
478 if (
Index >= Symbols.size())
479 return createError(
"unable to get symbol from section " +
481 ": invalid symbol index (" +
Twine(
Index) +
")");
482 return &Symbols[
Index];
489 if (Sec.sh_entsize !=
sizeof(
T) &&
sizeof(
T) != 1)
491 " has invalid sh_entsize: expected " +
Twine(
sizeof(
T)) +
492 ", but got " +
Twine(Sec.sh_entsize));
494 uintX_t
Offset = Sec.sh_offset;
495 uintX_t
Size = Sec.sh_size;
497 if (
Size %
sizeof(
T))
499 " has an invalid sh_size (" +
Twine(
Size) +
500 ") which is not a multiple of its sh_entsize (" +
501 Twine(Sec.sh_entsize) +
")");
502 if (std::numeric_limits<uintX_t>::max() -
Offset <
Size)
506 ") that cannot be represented");
511 ") that is greater than the file size (0x" +
518 const T *Start =
reinterpret_cast<const T *
>(base() +
Offset);
525 uintX_t
Offset = Phdr.p_offset;
526 uintX_t
Size = Phdr.p_filesz;
528 if (std::numeric_limits<uintX_t>::max() -
Offset <
Size)
532 ") that cannot be represented");
537 ") that is greater than the file size (0x" +
545 return getSectionContentsAsArray<uint8_t>(Sec);
556 if (!isMipsELF64()) {
558 Result.append(
Name.begin(),
Name.end());
566 uint8_t Type1 = (
Type >> 0) & 0xFF;
572 Result.append(
Name.begin(),
Name.end());
575 Result.append(1,
'/');
576 Result.append(
Name.begin(),
Name.end());
579 Result.append(1,
'/');
580 Result.append(
Name.begin(),
Name.end());
592 const Elf_Shdr *VerDefSec)
const {
600 auto InsertEntry = [&](
unsigned N,
StringRef Version,
bool IsVerdef) {
601 if (
N >= VersionMap.
size())
603 VersionMap[
N] = {std::string(Version), IsVerdef};
610 for (
const VerDef &Def : *Defs)
618 for (
const VerNeed &Dep : *Deps)
619 for (
const VernAux &Aux : Dep.AuxV)
629 const Elf_Shdr *SymTab)
const {
633 return getEntry<Elf_Sym>(*SymTab,
Index);
646 if (Sections.empty())
648 "e_shstrndx == SHN_XINDEX, but the section header table is empty");
650 Index = Sections[0].sh_link;
656 return FakeSectionStrings;
658 if (
Index >= Sections.size())
661 return getStringTable(Sections[
Index], WarnHandler);
670 const void *BufEnd) {
671 using Elf_Word =
typename ELFT::Word;
672 if (Table.nbuckets == 0)
673 return Table.symndx + 1;
676 for (Elf_Word Val : Table.buckets())
677 LastSymIdx = std::max(LastSymIdx, (
uint64_t)Val);
679 reinterpret_cast<const Elf_Word *
>(Table.values(LastSymIdx).end());
681 while (It < BufEnd && (*It & 1) == 0) {
688 "no terminator found for GNU hash section before buffer end");
690 return LastSymIdx + 1;
700 if (!SectionsOrError)
702 for (
const Elf_Shdr &Sec : *SectionsOrError) {
704 if (Sec.sh_size % Sec.sh_entsize != 0) {
706 "SHT_DYNSYM section has sh_size (" +
707 Twine(Sec.sh_size) +
") % sh_entsize (" +
708 Twine(Sec.sh_entsize) +
") that is not 0");
710 return Sec.sh_size / Sec.sh_entsize;
714 if (!SectionsOrError->empty()) {
725 std::optional<uint64_t> ElfHash;
726 std::optional<uint64_t> ElfGnuHash;
727 for (
const Elf_Dyn &Entry : *DynTable) {
728 switch (Entry.d_tag) {
730 ElfHash = Entry.d_un.d_ptr;
732 case ELF::DT_GNU_HASH:
733 ElfGnuHash = Entry.d_un.d_ptr;
741 const Elf_GnuHash *Table =
742 reinterpret_cast<const Elf_GnuHash *
>(TablePtr.
get());
743 return getDynSymtabSizeFromGnuHash<ELFT>(*Table, this->Buf.bytes_end());
751 const Elf_Hash *Table =
reinterpret_cast<const Elf_Hash *
>(TablePtr.
get());
752 return Table->nchain;
761 if (
sizeof(Elf_Ehdr) >
Object.size())
763 ") is smaller than an ELF header (" +
764 Twine(
sizeof(Elf_Ehdr)) +
")");
772 if (!FakeSections.empty())
774 auto PhdrsOrErr = program_headers();
778 FakeSectionStrings +=
'\0';
782 Elf_Shdr FakeShdr = {};
785 FakeShdr.sh_addr = Phdr.p_vaddr;
786 FakeShdr.sh_size = Phdr.p_memsz;
787 FakeShdr.sh_offset = Phdr.p_offset;
789 FakeShdr.sh_name = FakeSectionStrings.size();
790 FakeSectionStrings += (
"PT_LOAD#" +
Twine(
Idx)).str();
791 FakeSectionStrings +=
'\0';
792 FakeSections.push_back(FakeShdr);
798 const uintX_t SectionTableOffset = getHeader().e_shoff;
799 if (SectionTableOffset == 0) {
800 if (!FakeSections.empty())
801 return ArrayRef(FakeSections.data(), FakeSections.size());
805 if (getHeader().e_shentsize !=
sizeof(Elf_Shdr))
806 return createError(
"invalid e_shentsize in ELF header: " +
807 Twine(getHeader().e_shentsize));
809 const uint64_t FileSize = Buf.size();
810 if (SectionTableOffset +
sizeof(Elf_Shdr) > FileSize ||
811 SectionTableOffset + (uintX_t)
sizeof(Elf_Shdr) < SectionTableOffset)
813 "section header table goes past the end of the file: e_shoff = 0x" +
817 if (SectionTableOffset & (
alignof(Elf_Shdr) - 1))
819 return createError(
"invalid alignment of section headers");
821 const Elf_Shdr *First =
822 reinterpret_cast<const Elf_Shdr *
>(base() + SectionTableOffset);
824 uintX_t NumSections = getHeader().e_shnum;
825 if (NumSections == 0)
826 NumSections = First->sh_size;
828 if (NumSections >
UINT64_MAX /
sizeof(Elf_Shdr))
829 return createError(
"invalid number of sections specified in the NULL "
830 "section's sh_size field (" +
831 Twine(NumSections) +
")");
833 const uint64_t SectionTableSize = NumSections *
sizeof(Elf_Shdr);
834 if (SectionTableOffset + SectionTableSize < SectionTableOffset)
836 "invalid section header table offset (e_shoff = 0x" +
838 ") or invalid number of sections specified in the first section "
839 "header's sh_size field (0x" +
843 if (SectionTableOffset + SectionTableSize > FileSize)
844 return createError(
"section table goes past the end of file");
845 return ArrayRef(First, NumSections);
854 return SecOrErr.takeError();
855 return getEntry<T>(**SecOrErr, Entry);
867 if (Entry >= Arr.
size())
869 "can't read an entry at 0x" +
871 ": it goes past the end of the section (0x" +
876template <
typename ELFT>
878 uint32_t SymbolVersionIndex,
bool &IsDefault,
879 SmallVector<std::optional<VersionEntry>, 0> &VersionMap,
880 std::optional<bool> IsSymHidden)
const {
891 if (VersionIndex >= VersionMap.size() || !VersionMap[VersionIndex])
892 return createError(
"SHT_GNU_versym section refers to a version index " +
893 Twine(VersionIndex) +
" which is missing");
897 if (!Entry.IsVerDef || IsSymHidden.value_or(
false))
901 return Entry.Name.c_str();
916 const uint8_t *Start = ContentsOrErr->data();
917 const uint8_t *End = Start + ContentsOrErr->size();
919 auto ExtractNextAux = [&](
const uint8_t *&VerdauxBuf,
921 if (VerdauxBuf +
sizeof(Elf_Verdaux) > End)
923 ": version definition " +
Twine(VerDefNdx) +
924 " refers to an auxiliary entry that goes past the end "
927 auto *Verdaux =
reinterpret_cast<const Elf_Verdaux *
>(VerdauxBuf);
928 VerdauxBuf += Verdaux->vda_next;
931 Aux.
Offset = VerdauxBuf - Start;
932 if (Verdaux->vda_name <= StrTabOrErr->size())
933 Aux.
Name = std::string(StrTabOrErr->drop_front(Verdaux->vda_name));
935 Aux.
Name = (
"<invalid vda_name: " +
Twine(Verdaux->vda_name) +
">").str();
939 std::vector<VerDef> Ret;
940 const uint8_t *VerdefBuf = Start;
941 for (
unsigned I = 1;
I <= Sec.sh_info; ++
I) {
942 if (VerdefBuf +
sizeof(Elf_Verdef) > End)
944 ": version definition " +
Twine(
I) +
945 " goes past the end of the section");
947 if (
reinterpret_cast<uintptr_t
>(VerdefBuf) %
sizeof(
uint32_t) != 0)
950 ": found a misaligned version definition entry at offset 0x" +
953 unsigned Version = *
reinterpret_cast<const Elf_Half *
>(VerdefBuf);
956 ": version " +
Twine(Version) +
957 " is not yet supported");
959 const Elf_Verdef *
D =
reinterpret_cast<const Elf_Verdef *
>(VerdefBuf);
960 VerDef &VD = *Ret.emplace(Ret.end());
961 VD.
Offset = VerdefBuf - Start;
966 VD.
Hash =
D->vd_hash;
968 const uint8_t *VerdauxBuf = VerdefBuf +
D->vd_aux;
969 for (
unsigned J = 0; J <
D->vd_cnt; ++J) {
970 if (
reinterpret_cast<uintptr_t
>(VerdauxBuf) %
sizeof(
uint32_t) != 0)
972 ": found a misaligned auxiliary entry at offset 0x" +
980 VD.
Name = AuxOrErr->Name;
982 VD.
AuxV.push_back(*AuxOrErr);
985 VerdefBuf +=
D->vd_next;
1001 StrTab = *StrTabOrErr;
1009 const uint8_t *Start = ContentsOrErr->data();
1010 const uint8_t *End = Start + ContentsOrErr->size();
1011 const uint8_t *VerneedBuf = Start;
1013 std::vector<VerNeed> Ret;
1014 for (
unsigned I = 1;
I <= Sec.sh_info; ++
I) {
1015 if (VerneedBuf +
sizeof(Elf_Verdef) > End)
1017 ": version dependency " +
Twine(
I) +
1018 " goes past the end of the section");
1020 if (
reinterpret_cast<uintptr_t
>(VerneedBuf) %
sizeof(
uint32_t) != 0)
1022 "invalid " +
describe(*
this, Sec) +
1023 ": found a misaligned version dependency entry at offset 0x" +
1026 unsigned Version = *
reinterpret_cast<const Elf_Half *
>(VerneedBuf);
1029 ": version " +
Twine(Version) +
1030 " is not yet supported");
1032 const Elf_Verneed *Verneed =
1033 reinterpret_cast<const Elf_Verneed *
>(VerneedBuf);
1035 VerNeed &VN = *Ret.emplace(Ret.end());
1036 VN.
Version = Verneed->vn_version;
1037 VN.
Cnt = Verneed->vn_cnt;
1038 VN.
Offset = VerneedBuf - Start;
1040 if (Verneed->vn_file < StrTab.
size())
1041 VN.
File = std::string(StrTab.
data() + Verneed->vn_file);
1043 VN.
File = (
"<corrupt vn_file: " +
Twine(Verneed->vn_file) +
">").str();
1045 const uint8_t *VernauxBuf = VerneedBuf + Verneed->vn_aux;
1046 for (
unsigned J = 0; J < Verneed->vn_cnt; ++J) {
1047 if (
reinterpret_cast<uintptr_t
>(VernauxBuf) %
sizeof(
uint32_t) != 0)
1049 ": found a misaligned auxiliary entry at offset 0x" +
1052 if (VernauxBuf +
sizeof(Elf_Vernaux) > End)
1054 "invalid " +
describe(*
this, Sec) +
": version dependency " +
1056 " refers to an auxiliary entry that goes past the end "
1059 const Elf_Vernaux *Vernaux =
1060 reinterpret_cast<const Elf_Vernaux *
>(VernauxBuf);
1063 Aux.
Hash = Vernaux->vna_hash;
1064 Aux.
Flags = Vernaux->vna_flags;
1065 Aux.
Other = Vernaux->vna_other;
1066 Aux.
Offset = VernauxBuf - Start;
1067 if (StrTab.
size() <= Vernaux->vna_name)
1068 Aux.
Name =
"<corrupt>";
1072 VernauxBuf += Vernaux->vna_next;
1074 VerneedBuf += Verneed->vn_next;
1079template <
class ELFT>
1082 auto TableOrErr = sections();
1084 return TableOrErr.takeError();
1085 return object::getSection<ELFT>(*TableOrErr,
Index);
1088template <
class ELFT>
1093 if (
Error E = WarnHandler(
"invalid sh_type for string table section " +
1095 ": expected SHT_STRTAB, but got " +
1097 getHeader().e_machine, Section.sh_type)))
1098 return std::move(
E);
1100 auto V = getSectionContentsAsArray<char>(Section);
1102 return V.takeError();
1105 return createError(
"SHT_STRTAB string table section " +
1107 if (
Data.back() !=
'\0')
1108 return createError(
"SHT_STRTAB string table section " +
1110 " is non-null terminated");
1114template <
class ELFT>
1117 auto SectionsOrErr = sections();
1119 return SectionsOrErr.takeError();
1120 return getSHNDXTable(Section, *SectionsOrErr);
1123template <
class ELFT>
1126 Elf_Shdr_Range Sections)
const {
1128 auto VOrErr = getSectionContentsAsArray<Elf_Word>(Section);
1130 return VOrErr.takeError();
1132 auto SymTableOrErr = object::getSection<ELFT>(Sections, Section.sh_link);
1134 return SymTableOrErr.takeError();
1135 const Elf_Shdr &SymTable = **SymTableOrErr;
1139 "SHT_SYMTAB_SHNDX section is linked with " +
1141 " section (expected SHT_SYMTAB/SHT_DYNSYM)");
1143 uint64_t Syms = SymTable.sh_size /
sizeof(Elf_Sym);
1144 if (V.
size() != Syms)
1146 " entries, but the symbol table associated has " +
1152template <
class ELFT>
1155 auto SectionsOrErr = sections();
1157 return SectionsOrErr.takeError();
1158 return getStringTableForSymtab(Sec, *SectionsOrErr);
1161template <
class ELFT>
1164 Elf_Shdr_Range Sections)
const {
1168 "invalid sh_type for symbol table, expected SHT_SYMTAB or SHT_DYNSYM");
1170 object::getSection<ELFT>(Sections, Sec.sh_link);
1173 return getStringTable(**SectionOrErr);
1176template <
class ELFT>
1181 if (!StrTabSecOrErr)
1187 return createError(
"invalid string table linked to " +
1190 return *StrTabOrErr;
1193template <
class ELFT>
1197 auto SectionsOrErr = sections();
1199 return SectionsOrErr.takeError();
1200 auto Table = getSectionStringTable(*SectionsOrErr, WarnHandler);
1202 return Table.takeError();
1203 return getSectionName(Section, *Table);
1206template <
class ELFT>
1214 " has an invalid sh_name (0x" +
1216 ") offset which goes past the end of the "
1217 "section name string table");
1226 for (
char C : SymbolName) {
1228 g = h & 0xf0000000L;
1241 for (uint8_t
C :
Name)
1242 H = (
H << 5) +
H +
C;
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)
return ToRemove size() > 0
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallString class.
This file defines the SmallVector class.
INLINE void g(uint32_t *state, size_t a, size_t b, size_t c, size_t d, uint32_t x, uint32_t y)
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.
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< 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
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< std::vector< BBAddrMap > > decodeBBAddrMap(const Elf_Shdr &Sec) const
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.
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)
unsigned hashSysV(StringRef SymbolName)
This function returns the hash value for a symbol in the .dynsym section Name of the API remains cons...
@ 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)
std::string getSecIndexForError(const ELFFile< ELFT > &Obj, const typename ELFT::Shdr &Sec)
This is an optimization pass for GlobalISel generic memory operations.
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.
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
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