9#ifndef LLVM_OBJECT_ELFTYPES_H
10#define LLVM_OBJECT_ELFTYPES_H
29template <
class ELFT>
struct Elf_Ehdr_Impl;
30template <
class ELFT>
struct Elf_Shdr_Impl;
31template <
class ELFT>
struct Elf_Sym_Impl;
32template <
class ELFT>
struct Elf_Dyn_Impl;
48template <endianness E,
bool Is64>
struct ELFType {
50 template <
typename Ty>
57 using uint = std::conditional_t<Is64, uint64_t, uint32_t>;
104#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \
105 using Elf_Addr = typename ELFT::Addr; \
106 using Elf_Off = typename ELFT::Off; \
107 using Elf_Half = typename ELFT::Half; \
108 using Elf_Word = typename ELFT::Word; \
109 using Elf_Sword = typename ELFT::Sword; \
110 using Elf_Xword = typename ELFT::Xword; \
111 using Elf_Sxword = typename ELFT::Sxword; \
112 using uintX_t = typename ELFT::uint; \
113 using Elf_Ehdr = typename ELFT::Ehdr; \
114 using Elf_Shdr = typename ELFT::Shdr; \
115 using Elf_Sym = typename ELFT::Sym; \
116 using Elf_Dyn = typename ELFT::Dyn; \
117 using Elf_Phdr = typename ELFT::Phdr; \
118 using Elf_Rel = typename ELFT::Rel; \
119 using Elf_Rela = typename ELFT::Rela; \
120 using Elf_Relr = typename ELFT::Relr; \
121 using Elf_Verdef = typename ELFT::Verdef; \
122 using Elf_Verdaux = typename ELFT::Verdaux; \
123 using Elf_Verneed = typename ELFT::Verneed; \
124 using Elf_Vernaux = typename ELFT::Vernaux; \
125 using Elf_Versym = typename ELFT::Versym; \
126 using Elf_Hash = typename ELFT::Hash; \
127 using Elf_GnuHash = typename ELFT::GnuHash; \
128 using Elf_Chdr = typename ELFT::Chdr; \
129 using Elf_Nhdr = typename ELFT::Nhdr; \
130 using Elf_Note = typename ELFT::Note; \
131 using Elf_Note_Iterator = typename ELFT::NoteIterator; \
132 using Elf_CGProfile = typename ELFT::CGProfile; \
133 using Elf_Dyn_Range = typename ELFT::DynRange; \
134 using Elf_Shdr_Range = typename ELFT::ShdrRange; \
135 using Elf_Sym_Range = typename ELFT::SymRange; \
136 using Elf_Rel_Range = typename ELFT::RelRange; \
137 using Elf_Rela_Range = typename ELFT::RelaRange; \
138 using Elf_Relr_Range = typename ELFT::RelrRange; \
139 using Elf_Phdr_Range = typename ELFT::PhdrRange;
141#define LLVM_ELF_COMMA ,
142#define LLVM_ELF_IMPORT_TYPES(E, W) \
143 LLVM_ELF_IMPORT_TYPES_ELFT(ELFType<E LLVM_ELF_COMMA W>)
148template <endianness Endianness>
159 Elf_Word sh_addralign;
174 Elf_Xword sh_addralign;
175 Elf_Xword sh_entsize;
187 return sh_size / sh_entsize;
193template <endianness Endianness>
199 unsigned char st_info;
200 unsigned char st_other;
208 unsigned char st_info;
209 unsigned char st_other;
225 unsigned char getType()
const {
return st_info & 0x0f; }
228 void setType(
unsigned char t) { setBindingAndType(getBinding(), t); }
231 st_info = (b << 4) + (t & 0x0f);
241 assert(v < 4 &&
"Invalid value for visibility");
242 st_other = (st_other & ~0x3) | v;
248 return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
254 return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
258 return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
264 return st_shndx >= ELF::SHN_LORESERVE;
270 return getBinding() != ELF::STB_LOCAL;
281 "st_name (0x%" PRIx32
282 ") is past the end of the string table"
311 return reinterpret_cast<const Elf_Verdaux *
>((
const char *)
this + vd_aux);
362template <endianness Endianness>
377 using intX_t = std::conditional_t<ELFT::Is64Bits, int64_t, int32_t>;
378 using uintX_t = std::conditional_t<ELFT::Is64Bits, uint64_t, uint32_t>;
384template <endianness Endianness>
406 return (
unsigned char)(this->getRInfo(
isMips64EL) & 0x0ff);
409 setSymbolAndType(s,
getType(IsMips64EL), IsMips64EL);
411 void setType(
unsigned char t,
bool IsMips64EL) {
412 setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
415 this->setRInfo((s << 8) + t, IsMips64EL);
419template <endianness Endianness>
421 :
public Elf_Rel_Impl<ELFType<Endianness, false>, false> {
441 return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) |
442 ((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff);
447 r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
448 ((R & 0x0000ff00) << 40) | ((R & 0x000000ff) << 56);
462 setSymbolAndType(s,
getType(IsMips64EL), IsMips64EL);
465 setSymbolAndType(getSymbol(IsMips64EL), t, IsMips64EL);
468 this->setRInfo(((
uint64_t)s << 32) + (t & 0xffffffffL), IsMips64EL);
472template <endianness Endianness>
474 :
public Elf_Rel_Impl<ELFType<Endianness, true>, false> {
492 Elf_Half e_phentsize;
494 Elf_Half e_shentsize;
499 bool checkMagic()
const {
500 return (
memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
507template <endianness Endianness>
546 &nbucket + 2 + nbucket + nchain);
566 reinterpret_cast<const Elf_Word *
>(filter().end()), nbuckets);
570 assert(DynamicSymCount >= symndx);
577template <endianness Endianness>
582 Elf_Word ch_addralign;
589 Elf_Word ch_reserved;
591 Elf_Xword ch_addralign;
631 return StringRef(
reinterpret_cast<const char *
>(&Nhdr) +
sizeof(Nhdr),
640 reinterpret_cast<const uint8_t *
>(&Nhdr) +
666 size_t RemainingSize = 0u;
668 Error *Err =
nullptr;
670 template <
class ELFFileELFT>
friend class ELFFile;
673 void stopWithOverflowError() {
675 *Err = make_error<StringError>(
"ELF note overflows container",
676 object_error::parse_failed);
684 void advanceNhdr(
const uint8_t *NhdrPos,
size_t NoteSize) {
685 RemainingSize -= NoteSize;
686 if (RemainingSize == 0u) {
689 *Err = Error::success();
691 }
else if (
sizeof(*Nhdr) > RemainingSize)
692 stopWithOverflowError();
694 Nhdr =
reinterpret_cast<const Elf_Nhdr_Impl<ELFT> *
>(NhdrPos + NoteSize);
696 stopWithOverflowError();
698 *Err = Error::success();
702 Elf_Note_Iterator_Impl() =
default;
703 explicit Elf_Note_Iterator_Impl(Error &Err) : Err(&Err) {}
704 Elf_Note_Iterator_Impl(
const uint8_t *Start,
size_t Size,
size_t Align,
708 assert(Start &&
"ELF note iterator starting at NULL");
709 advanceNhdr(Start, 0u);
714 assert(Nhdr &&
"incremented ELF note end iterator");
715 const uint8_t *NhdrPos =
reinterpret_cast<const uint8_t *
>(Nhdr);
717 advanceNhdr(NhdrPos, NoteSize);
721 if (!Nhdr &&
Other.Err)
722 (void)(
bool)(*
Other.Err);
723 if (!
Other.Nhdr && Err)
725 return Nhdr ==
Other.Nhdr;
728 return !(*
this ==
Other);
731 assert(Nhdr &&
"dereferenced ELF note end iterator");
738 Elf_Xword cgp_weight;
749 Elf_Word ri_cprmask[4];
750 Elf_Addr ri_gp_value;
758 Elf_Word ri_cprmask[4];
759 Elf_Addr ri_gp_value;
772 assert(kind == ELF::ODK_REGINFO);
815 (
static_cast<uint8_t
>(
BBFreq) << 1) |
816 (
static_cast<uint8_t
>(
BrProb) << 2) |
817 (
static_cast<uint8_t
>(MultiBBRange) << 3);
824 static_cast<bool>(Val & (1 << 0)),
static_cast<bool>(Val & (1 << 1)),
825 static_cast<bool>(Val & (1 << 2)),
static_cast<bool>(Val & (1 << 3))};
826 if (Feat.encode() != Val)
828 std::error_code(),
"invalid encoding for BBAddrMap::Features: 0x%x",
852 return HasReturn ==
Other.HasReturn &&
853 HasTailCall ==
Other.HasTailCall && IsEHPad ==
Other.IsEHPad &&
854 CanFallThrough ==
Other.CanFallThrough &&
855 HasIndirectBranch ==
Other.HasIndirectBranch;
860 return static_cast<uint32_t>(HasReturn) |
861 (
static_cast<uint32_t>(HasTailCall) << 1) |
862 (
static_cast<uint32_t>(IsEHPad) << 2) |
863 (
static_cast<uint32_t>(CanFallThrough) << 3) |
864 (
static_cast<uint32_t>(HasIndirectBranch) << 4);
869 Metadata MD{
static_cast<bool>(V & 1),
870 static_cast<bool>(V & (1 << 1)),
871 static_cast<bool>(V & (1 << 2)),
872 static_cast<bool>(V & (1 << 3)),
873 static_cast<bool>(V & (1 << 4))};
874 if (MD.encode() != V)
876 std::error_code(),
"invalid encoding for BBEntry::Metadata: 0x%x",
911 return BaseAddress ==
Other.BaseAddress &&
912 std::equal(BBEntries.begin(), BBEntries.end(),
913 Other.BBEntries.begin());
924 assert(!BBRanges.empty());
925 return BBRanges.front().BaseAddress;
930 size_t NumBBEntries = 0;
931 for (
const auto &BBR : BBRanges)
932 NumBBEntries += BBR.BBEntries.size();
938 std::optional<size_t>
940 for (
size_t I = 0;
I < BBRanges.size(); ++
I)
941 if (BBRanges[
I].BaseAddress == BaseAddress)
948 return BBRanges.front().BBEntries;
951 const std::vector<BBRangeEntry> &
getBBRanges()
const {
return BBRanges; }
955 return std::equal(BBRanges.begin(), BBRanges.end(),
Other.BBRanges.begin());
973 return std::tie(
ID, Prob) == std::tie(
Other.ID,
Other.Prob);
983 return std::tie(BlockFreq, Successors) ==
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.
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.
constexpr size_t size() const
size - Get the string size.
constexpr 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.
void consumeError(Error Err)
Consume a Error without doing anything.
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)
bool operator==(const BBRangeEntry &Other) const
std::vector< BBEntry > BBEntries
bool operator==(const Features &Other) const
bool hasPGOAnalysisBBData() const
static Expected< Features > decode(uint8_t Val)
bool hasPGOAnalysis() const
const std::vector< BBRangeEntry > & getBBRanges() const
std::vector< BBRangeEntry > BBRanges
size_t getNumBBEntries() const
bool operator==(const BBAddrMap &Other) const
const std::vector< BBEntry > & getBBEntries() const
uint64_t getFunctionAddress() const
std::optional< size_t > getBBRangeIndexForBaseAddress(uint64_t BaseAddress) const
std::conditional_t< Is64, uint64_t, uint32_t > uint
static const endianness Endianness
static const bool Is64Bits
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.
unsigned char getType(bool isMips64EL) const
void setType(unsigned char t, bool IsMips64EL)
void setRInfo(uint32_t R, bool IsMips64EL)
uint32_t getSymbol(bool isMips64EL) const
void setSymbolAndType(uint32_t s, unsigned char t, bool IsMips64EL)
void setSymbol(uint32_t s, bool IsMips64EL)
void setType(uint32_t t, bool IsMips64EL)
void setSymbolAndType(uint32_t s, uint32_t t, bool IsMips64EL)
void setSymbol(uint32_t s, bool IsMips64EL)
uint32_t getSymbol(bool isMips64EL) const
void setRInfo(uint64_t R, 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).
Single successor of a given basic block that contains the tag and branch probability associated with ...
uint32_t ID
Unique ID of this successor basic block.
BranchProbability Prob
Branch Probability of the edge to this successor taken from MBPI.
bool operator==(const SuccessorEntry &Other) const
Extra basic block data with fields for block frequency and branch probability.
bool operator==(const PGOBBEntry &Other) const
llvm::SmallVector< SuccessorEntry, 2 > Successors
List of successors of the current block.
BlockFrequency BlockFreq
Block frequency taken from MBFI.
A feature extension of BBAddrMap that holds information relevant to PGO.
bool operator==(const PGOAnalysisMap &Other) const
std::vector< PGOBBEntry > BBEntries
BBAddrMap::Features FeatEnable