16 #define STRINGIFY_ENUM_CASE(ns, name) \
20 #define ELF_RELOC(name, value) STRINGIFY_ENUM_CASE(ELF, name)
27 #include "llvm/BinaryFormat/ELFRelocs/M68k.def"
34 #include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
42 #include "llvm/BinaryFormat/ELFRelocs/i386.def"
49 #include "llvm/BinaryFormat/ELFRelocs/Mips.def"
56 #include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
63 #include "llvm/BinaryFormat/ELFRelocs/ARM.def"
71 #include "llvm/BinaryFormat/ELFRelocs/ARC.def"
78 #include "llvm/BinaryFormat/ELFRelocs/AVR.def"
85 #include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
92 #include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
99 #include "llvm/BinaryFormat/ELFRelocs/PowerPC.def"
106 #include "llvm/BinaryFormat/ELFRelocs/PowerPC64.def"
113 #include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
120 #include "llvm/BinaryFormat/ELFRelocs/SystemZ.def"
129 #include "llvm/BinaryFormat/ELFRelocs/Sparc.def"
136 #include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
143 #include "llvm/BinaryFormat/ELFRelocs/BPF.def"
150 #include "llvm/BinaryFormat/ELFRelocs/MSP430.def"
157 #include "llvm/BinaryFormat/ELFRelocs/VE.def"
164 #include "llvm/BinaryFormat/ELFRelocs/CSKY.def"
171 #include "llvm/BinaryFormat/ELFRelocs/LoongArch.def"
178 #include "llvm/BinaryFormat/ELFRelocs/Xtensa.def"
194 return ELF::R_X86_64_RELATIVE;
197 return ELF::R_386_RELATIVE;
201 return ELF::R_AARCH64_RELATIVE;
203 return ELF::R_ARM_RELATIVE;
206 return ELF::R_ARC_RELATIVE;
210 return ELF::R_HEX_RELATIVE;
216 return ELF::R_PPC64_RELATIVE;
218 return ELF::R_RISCV_RELATIVE;
220 return ELF::R_390_RELATIVE;
224 return ELF::R_SPARC_RELATIVE;
226 return ELF::R_CKCORE_RELATIVE;
228 return ELF::R_VE_RELATIVE;
234 return ELF::R_LARCH_RELATIVE;
320 template <
class ELFT>
321 std::vector<typename ELFT::Rel>
355 Rel.setType(getRelativeRelocationType(),
false);
356 std::vector<Elf_Rel> Relocs;
362 for (Elf_Relr R : relrs) {
364 if ((Entry & 1) == 0) {
366 Rel.r_offset = Entry;
367 Relocs.push_back(Rel);
372 for (
Addr Offset =
Base; (Entry >>= 1) != 0; Offset +=
sizeof(
Addr))
373 if ((Entry & 1) != 0) {
374 Rel.r_offset = Offset;
375 Relocs.push_back(Rel);
377 Base += (CHAR_BIT *
sizeof(Entry) - 1) *
sizeof(
Addr);
384 template <
class ELFT>
395 return createError(
"invalid packed relocation header");
406 std::vector<Elf_Rela> Relocs;
407 Relocs.reserve(NumRelocs);
412 if (NumRelocsInGroup > NumRelocs)
413 return createError(
"relocation group unexpectedly large");
414 NumRelocs -= NumRelocsInGroup;
423 if (GroupedByOffsetDelta)
424 GroupOffsetDelta =
Data.getSLEB128(Cur);
428 GroupRInfo =
Data.getSLEB128(Cur);
430 if (GroupedByAddend && GroupHasAddend)
431 Addend +=
Data.getSLEB128(Cur);
436 for (
uint64_t I = 0; Cur &&
I != NumRelocsInGroup; ++
I) {
438 Offset += GroupedByOffsetDelta ? GroupOffsetDelta :
Data.getSLEB128(Cur);
440 R.r_info = GroupedByInfo ? GroupRInfo :
Data.getSLEB128(Cur);
441 if (GroupHasAddend && !GroupedByAddend)
442 Addend +=
Data.getSLEB128(Cur);
453 template <
class ELFT>
456 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \
460 #define DYNAMIC_TAG(n, v)
464 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
465 #include "llvm/BinaryFormat/DynamicTags.def"
466 #undef AARCH64_DYNAMIC_TAG
472 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
473 #include "llvm/BinaryFormat/DynamicTags.def"
474 #undef HEXAGON_DYNAMIC_TAG
480 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
481 #include "llvm/BinaryFormat/DynamicTags.def"
482 #undef MIPS_DYNAMIC_TAG
488 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
489 #include "llvm/BinaryFormat/DynamicTags.def"
490 #undef PPC_DYNAMIC_TAG
496 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
497 #include "llvm/BinaryFormat/DynamicTags.def"
498 #undef PPC64_DYNAMIC_TAG
504 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
505 #include "llvm/BinaryFormat/DynamicTags.def"
506 #undef RISCV_DYNAMIC_TAG
513 #define AARCH64_DYNAMIC_TAG(name, value)
514 #define MIPS_DYNAMIC_TAG(name, value)
515 #define HEXAGON_DYNAMIC_TAG(name, value)
516 #define PPC_DYNAMIC_TAG(name, value)
517 #define PPC64_DYNAMIC_TAG(name, value)
518 #define RISCV_DYNAMIC_TAG(name, value)
520 #define DYNAMIC_TAG_MARKER(name, value)
521 #define DYNAMIC_TAG(name, value) case value: return #name;
522 #include "llvm/BinaryFormat/DynamicTags.def"
524 #undef AARCH64_DYNAMIC_TAG
525 #undef MIPS_DYNAMIC_TAG
526 #undef HEXAGON_DYNAMIC_TAG
527 #undef PPC_DYNAMIC_TAG
528 #undef PPC64_DYNAMIC_TAG
529 #undef RISCV_DYNAMIC_TAG
530 #undef DYNAMIC_TAG_MARKER
531 #undef DYNAMIC_STRINGIFY_ENUM
533 return "<unknown:>0x" + utohexstr(
Type,
true);
537 template <
class ELFT>
539 return getDynamicTagAsString(getHeader().e_machine,
Type);
542 template <
class ELFT>
546 auto ProgramHeadersOrError = program_headers();
547 if (!ProgramHeadersOrError)
548 return ProgramHeadersOrError.takeError();
550 for (
const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
552 Dyn =
ArrayRef(
reinterpret_cast<const Elf_Dyn *
>(
base() + Phdr.p_offset),
553 Phdr.p_filesz /
sizeof(Elf_Dyn));
561 auto SectionsOrError = sections();
562 if (!SectionsOrError)
563 return SectionsOrError.takeError();
565 for (
const Elf_Shdr &Sec : *SectionsOrError) {
568 getSectionContentsAsArray<Elf_Dyn>(Sec);
581 return createError(
"invalid empty dynamic section");
583 if (Dyn.
back().d_tag != ELF::DT_NULL)
584 return createError(
"dynamic sections must be DT_NULL terminated");
589 template <
class ELFT>
592 auto ProgramHeadersOrError = program_headers();
593 if (!ProgramHeadersOrError)
594 return ProgramHeadersOrError.takeError();
598 for (
const Elf_Phdr &Phdr : *ProgramHeadersOrError)
600 LoadSegments.push_back(
const_cast<Elf_Phdr *
>(&Phdr));
604 return A->p_vaddr <
B->p_vaddr;
608 WarnHandler(
"loadable segments are unsorted by virtual address"))
615 return VAddr < Phdr->p_vaddr;
618 if (
I == LoadSegments.begin())
619 return createError(
"virtual address is not in any segment: 0x" +
622 const Elf_Phdr &Phdr = **
I;
623 uint64_t Delta = VAddr - Phdr.p_vaddr;
624 if (Delta >= Phdr.p_filesz)
625 return createError(
"virtual address is not in any segment: 0x" +
628 uint64_t Offset = Phdr.p_offset + Delta;
629 if (Offset >= getBufSize())
630 return createError(
"can't map virtual address 0x" +
632 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
633 ": the segment ends at 0x" +
635 ", which is greater than the file size (0x" +
638 return base() + Offset;
641 template <
class ELFT>
649 std::vector<BBAddrMap> FunctionEntries;
657 auto ReadULEB128AsUInt32 = [&
Data, &Cur, &ULEBSizeErr]() ->
uint32_t {
663 if (
Value > UINT32_MAX) {
673 while (!ULEBSizeErr && Cur && Cur.tell() <
Content.size()) {
679 return createError(
"unsupported SHT_LLVM_BB_ADDR_MAP version: " +
683 uintX_t Address =
static_cast<uintX_t
>(
Data.getAddress(Cur));
684 uint32_t NumBlocks = ReadULEB128AsUInt32();
685 std::vector<BBAddrMap::BBEntry> BBEntries;
688 !ULEBSizeErr && Cur && (BlockIndex < NumBlocks); ++BlockIndex) {
690 uint32_t Offset = ReadULEB128AsUInt32();
691 uint32_t Size = ReadULEB128AsUInt32();
695 Offset += PrevBBEndOffset;
696 PrevBBEndOffset = Offset + Size;
698 BBEntries.push_back({
ID, Offset, Size,
Metadata});
700 FunctionEntries.push_back({Address,
std::move(BBEntries)});
704 if (!Cur || ULEBSizeErr)
706 return FunctionEntries;