9#ifndef LLVM_OBJECT_ELFTYPES_H
10#define LLVM_OBJECT_ELFTYPES_H
27template <
class ELFT>
struct Elf_Ehdr_Impl;
28template <
class ELFT>
struct Elf_Shdr_Impl;
29template <
class ELFT>
struct Elf_Sym_Impl;
30template <
class ELFT>
struct Elf_Dyn_Impl;
46template <endianness E,
bool Is64>
struct ELFType {
48 template <
typename Ty>
55 using uint = std::conditional_t<Is64, uint64_t, uint32_t>;
102#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \
103 using Elf_Addr = typename ELFT::Addr; \
104 using Elf_Off = typename ELFT::Off; \
105 using Elf_Half = typename ELFT::Half; \
106 using Elf_Word = typename ELFT::Word; \
107 using Elf_Sword = typename ELFT::Sword; \
108 using Elf_Xword = typename ELFT::Xword; \
109 using Elf_Sxword = typename ELFT::Sxword; \
110 using uintX_t = typename ELFT::uint; \
111 using Elf_Ehdr = typename ELFT::Ehdr; \
112 using Elf_Shdr = typename ELFT::Shdr; \
113 using Elf_Sym = typename ELFT::Sym; \
114 using Elf_Dyn = typename ELFT::Dyn; \
115 using Elf_Phdr = typename ELFT::Phdr; \
116 using Elf_Rel = typename ELFT::Rel; \
117 using Elf_Rela = typename ELFT::Rela; \
118 using Elf_Relr = typename ELFT::Relr; \
119 using Elf_Verdef = typename ELFT::Verdef; \
120 using Elf_Verdaux = typename ELFT::Verdaux; \
121 using Elf_Verneed = typename ELFT::Verneed; \
122 using Elf_Vernaux = typename ELFT::Vernaux; \
123 using Elf_Versym = typename ELFT::Versym; \
124 using Elf_Hash = typename ELFT::Hash; \
125 using Elf_GnuHash = typename ELFT::GnuHash; \
126 using Elf_Chdr = typename ELFT::Chdr; \
127 using Elf_Nhdr = typename ELFT::Nhdr; \
128 using Elf_Note = typename ELFT::Note; \
129 using Elf_Note_Iterator = typename ELFT::NoteIterator; \
130 using Elf_CGProfile = typename ELFT::CGProfile; \
131 using Elf_Dyn_Range = typename ELFT::DynRange; \
132 using Elf_Shdr_Range = typename ELFT::ShdrRange; \
133 using Elf_Sym_Range = typename ELFT::SymRange; \
134 using Elf_Rel_Range = typename ELFT::RelRange; \
135 using Elf_Rela_Range = typename ELFT::RelaRange; \
136 using Elf_Relr_Range = typename ELFT::RelrRange; \
137 using Elf_Phdr_Range = typename ELFT::PhdrRange;
139#define LLVM_ELF_COMMA ,
140#define LLVM_ELF_IMPORT_TYPES(E, W) \
141 LLVM_ELF_IMPORT_TYPES_ELFT(ELFType<E LLVM_ELF_COMMA W>)
146template <endianness TargetEndianness>
157 Elf_Word sh_addralign;
172 Elf_Xword sh_addralign;
173 Elf_Xword sh_entsize;
185 return sh_size / sh_entsize;
191template <endianness TargetEndianness>
197 unsigned char st_info;
198 unsigned char st_other;
206 unsigned char st_info;
207 unsigned char st_other;
223 unsigned char getType()
const {
return st_info & 0x0f; }
226 void setType(
unsigned char t) { setBindingAndType(getBinding(), t); }
229 st_info = (b << 4) + (t & 0x0f);
239 assert(v < 4 &&
"Invalid value for visibility");
240 st_other = (st_other & ~0x3) | v;
246 return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
252 return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
256 return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
262 return st_shndx >= ELF::SHN_LORESERVE;
268 return getBinding() != ELF::STB_LOCAL;
279 "st_name (0x%" PRIx32
280 ") is past the end of the string table"
309 return reinterpret_cast<const Elf_Verdaux *
>((
const char *)
this + vd_aux);
360template <endianness TargetEndianness>
375 using intX_t = std::conditional_t<ELFT::Is64Bits, int64_t, int32_t>;
376 using uintX_t = std::conditional_t<ELFT::Is64Bits, uint64_t, uint32_t>;
382template <endianness TargetEndianness>
404 return (
unsigned char)(this->getRInfo(
isMips64EL) & 0x0ff);
407 setSymbolAndType(s,
getType(IsMips64EL), IsMips64EL);
409 void setType(
unsigned char t,
bool IsMips64EL) {
410 setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
413 this->setRInfo((s << 8) + t, IsMips64EL);
417template <endianness TargetEndianness>
419 :
public Elf_Rel_Impl<ELFType<TargetEndianness, false>, false> {
439 return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) |
440 ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff);
445 r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
446 ((R & 0x0000ff00) << 40) | ((R & 0x000000ff) << 56);
460 setSymbolAndType(s,
getType(IsMips64EL), IsMips64EL);
463 setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
466 this->setRInfo(((
uint64_t)s << 32) + (t & 0xffffffffL), IsMips64EL);
470template <endianness TargetEndianness>
472 :
public Elf_Rel_Impl<ELFType<TargetEndianness, true>, false> {
490 Elf_Half e_phentsize;
492 Elf_Half e_shentsize;
497 bool checkMagic()
const {
498 return (
memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
505template <endianness TargetEndianness>
544 &nbucket + 2 + nbucket + nchain);
564 reinterpret_cast<const Elf_Word *
>(filter().end()), nbuckets);
568 assert(DynamicSymCount >= symndx);
575template <endianness TargetEndianness>
580 Elf_Word ch_addralign;
587 Elf_Word ch_reserved;
589 Elf_Xword ch_addralign;
629 return StringRef(
reinterpret_cast<const char *
>(&Nhdr) +
sizeof(Nhdr),
638 reinterpret_cast<const uint8_t *
>(&Nhdr) +
664 size_t RemainingSize = 0u;
666 Error *Err =
nullptr;
668 template <
class ELFFileELFT>
friend class ELFFile;
671 void stopWithOverflowError() {
673 *Err = make_error<StringError>(
"ELF note overflows container",
674 object_error::parse_failed);
682 void advanceNhdr(
const uint8_t *NhdrPos,
size_t NoteSize) {
683 RemainingSize -= NoteSize;
684 if (RemainingSize == 0u) {
687 *Err = Error::success();
689 }
else if (
sizeof(*Nhdr) > RemainingSize)
690 stopWithOverflowError();
692 Nhdr =
reinterpret_cast<const Elf_Nhdr_Impl<ELFT> *
>(NhdrPos + NoteSize);
694 stopWithOverflowError();
696 *Err = Error::success();
700 Elf_Note_Iterator_Impl() =
default;
701 explicit Elf_Note_Iterator_Impl(Error &Err) : Err(&Err) {}
702 Elf_Note_Iterator_Impl(
const uint8_t *Start,
size_t Size,
size_t Align,
706 assert(Start &&
"ELF note iterator starting at NULL");
707 advanceNhdr(Start, 0u);
712 assert(Nhdr &&
"incremented ELF note end iterator");
713 const uint8_t *NhdrPos =
reinterpret_cast<const uint8_t *
>(Nhdr);
715 advanceNhdr(NhdrPos, NoteSize);
719 if (!Nhdr &&
Other.Err)
720 (void)(
bool)(*
Other.Err);
721 if (!
Other.Nhdr && Err)
723 return Nhdr ==
Other.Nhdr;
726 return !(*
this ==
Other);
729 assert(Nhdr &&
"dereferenced ELF note end iterator");
736 Elf_Xword cgp_weight;
747 Elf_Word ri_cprmask[4];
748 Elf_Addr ri_gp_value;
756 Elf_Word ri_cprmask[4];
757 Elf_Addr ri_gp_value;
770 assert(kind == ELF::ODK_REGINFO);
809 return HasReturn ==
Other.HasReturn &&
810 HasTailCall ==
Other.HasTailCall && IsEHPad ==
Other.IsEHPad &&
811 CanFallThrough ==
Other.CanFallThrough &&
812 HasIndirectBranch ==
Other.HasIndirectBranch;
817 return static_cast<uint32_t>(HasReturn) |
818 (
static_cast<uint32_t>(HasTailCall) << 1) |
819 (
static_cast<uint32_t>(IsEHPad) << 2) |
820 (
static_cast<uint32_t>(CanFallThrough) << 3) |
821 (
static_cast<uint32_t>(HasIndirectBranch) << 4);
826 Metadata MD{
static_cast<bool>(V & 1),
827 static_cast<bool>(V & (1 << 1)),
828 static_cast<bool>(V & (1 << 2)),
829 static_cast<bool>(V & (1 << 3)),
830 static_cast<bool>(V & (1 << 4))};
831 if (MD.encode() != V)
833 std::error_code(),
"invalid encoding for BBEntry::Metadata: 0x%x",
870 return Addr ==
Other.Addr && std::equal(BBEntries.begin(), BBEntries.end(),
871 Other.BBEntries.begin());
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static bool isMips64EL(const ELFYAML::Object &Obj)
#define LLVM_ELF_IMPORT_TYPES(E, W)
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
std::optional< std::vector< StOtherPiece > > Other
Merge contiguous icmps into a memcmp
static StringRef getName(Value *V)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static SymbolRef::Type getType(const Symbol *Sym)
static unsigned getSize(unsigned Kind)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Lightweight error class with error context and mandatory checking.
Tagged union holding either a T or a Error.
StringRef - Represent a constant reference to a string, i.e.
constexpr size_t size() const
size - Get the string size.
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
StringRef getDescAsStringRef(size_t Align) const
Get the note's descriptor as StringRef.
Elf_Word getType() const
Get the note's type.
Elf_Note_Impl(const Elf_Nhdr_Impl< ELFT > &Nhdr)
StringRef getName() const
Get the note's name, excluding the terminating null byte.
ArrayRef< uint8_t > getDesc(size_t Align) const
Get the note's descriptor.
bool operator!=(Elf_Note_Iterator_Impl Other) const
std::forward_iterator_tag iterator_category
std::ptrdiff_t difference_type
Elf_Note_Impl< ELFT > operator*() const
Elf_Note_Iterator_Impl & operator++()
bool operator==(Elf_Note_Iterator_Impl Other) const
This is an optimization pass for GlobalISel generic memory operations.
uint64_t alignToPowerOf2(uint64_t Value, uint64_t Align)
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
void consumeError(Error Err)
Consume a Error without doing anything.
Implement std::hash so that hash_code can be used in STL containers.
This struct is a compact representation of a valid (non-zero power of two) alignment.
Description of the encoding of one expression Op.
static Expected< Metadata > decode(uint32_t V)
bool operator==(const Metadata &Other) const
bool canFallThrough() const
bool hasIndirectBranch() const
bool operator==(const BBEntry &Other) const
BBEntry(uint32_t ID, uint32_t Offset, uint32_t Size, Metadata MD)
std::vector< BBEntry > BBEntries
BBAddrMap(uint64_t Addr, std::vector< BBEntry > BBEntries)
bool operator==(const BBAddrMap &Other) const
const std::vector< BBEntry > & getBBEntries() const
uint64_t getFunctionAddress() const
std::conditional_t< Is64, uint64_t, uint32_t > uint
static const bool Is64Bits
static const endianness TargetEndianness
Elf_Dyn_Base: This structure matches the form of entries in the dynamic table section (....
Elf_Dyn_Impl: This inherits from Elf_Dyn_Base, adding getters.
std::conditional_t< ELFT::Is64Bits, int64_t, int32_t > intX_t
std::conditional_t< ELFT::Is64Bits, uint64_t, uint32_t > uintX_t
unsigned char getFileClass() const
unsigned char getDataEncoding() const
ArrayRef< Elf_Word > values(unsigned DynamicSymCount) const
ArrayRef< Elf_Word > buckets() const
ArrayRef< Elf_Word > chains() const
const Elf_Mips_RegInfo< ELFT > & getRegInfo() const
size_t getSize(size_t Align) const
Get the size of the note, including name, descriptor, and padding.
void setSymbol(uint32_t s, bool IsMips64EL)
void setSymbolAndType(uint32_t s, unsigned char t, bool IsMips64EL)
void setType(unsigned char t, bool IsMips64EL)
uint32_t getSymbol(bool isMips64EL) const
unsigned char getType(bool isMips64EL) const
void setRInfo(uint32_t R, bool IsMips64EL)
void setSymbolAndType(uint32_t s, uint32_t t, bool IsMips64EL)
void setRInfo(uint64_t R, bool IsMips64EL)
uint32_t getSymbol(bool isMips64EL) const
void setSymbol(uint32_t s, bool IsMips64EL)
void setType(uint32_t t, bool IsMips64EL)
uint32_t getType(bool isMips64EL) const
unsigned getEntityCount() const
Get the number of entities this section contains if it has any.
void setBindingAndType(unsigned char b, unsigned char t)
bool isProcessorSpecific() const
void setBinding(unsigned char b)
unsigned char getBinding() const
bool isOSSpecific() const
unsigned char getType() const
uint64_t getValue() const
void setVisibility(unsigned char v)
void setType(unsigned char t)
unsigned char getVisibility() const
Access to the STV_xxx flag stored in the first two bits of st_other.
Elf_Verdaux: This is the structure of auxiliary data in the SHT_GNU_verdef section (....
Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section (.gnu.version_d).
Elf_Vernaux: This is the structure of auxiliary data in SHT_GNU_verneed section (....
Elf_Verneed: This is the structure of entries in the SHT_GNU_verneed section (.gnu....
Elf_Versym: This is the structure of entries in the SHT_GNU_versym section (.gnu.version).