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"
187 return ELF::R_X86_64_RELATIVE;
190 return ELF::R_386_RELATIVE;
194 return ELF::R_AARCH64_RELATIVE;
196 return ELF::R_ARM_RELATIVE;
199 return ELF::R_ARC_RELATIVE;
203 return ELF::R_HEX_RELATIVE;
209 return ELF::R_PPC64_RELATIVE;
211 return ELF::R_RISCV_RELATIVE;
213 return ELF::R_390_RELATIVE;
217 return ELF::R_SPARC_RELATIVE;
219 return ELF::R_CKCORE_RELATIVE;
221 return ELF::R_VE_RELATIVE;
310 template <
class ELFT>
311 std::vector<typename ELFT::Rel>
345 Rel.setType(getRelativeRelocationType(),
false);
346 std::vector<Elf_Rel> Relocs;
352 for (Elf_Relr R : relrs) {
354 if ((Entry & 1) == 0) {
356 Rel.r_offset = Entry;
357 Relocs.push_back(Rel);
362 for (
Addr Offset =
Base; (Entry >>= 1) != 0; Offset +=
sizeof(
Addr))
363 if ((Entry & 1) != 0) {
364 Rel.r_offset = Offset;
365 Relocs.push_back(Rel);
367 Base += (CHAR_BIT *
sizeof(Entry) - 1) *
sizeof(
Addr);
374 template <
class ELFT>
385 return createError(
"invalid packed relocation header");
396 std::vector<Elf_Rela> Relocs;
397 Relocs.reserve(NumRelocs);
402 if (NumRelocsInGroup > NumRelocs)
403 return createError(
"relocation group unexpectedly large");
404 NumRelocs -= NumRelocsInGroup;
413 if (GroupedByOffsetDelta)
414 GroupOffsetDelta =
Data.getSLEB128(Cur);
418 GroupRInfo =
Data.getSLEB128(Cur);
420 if (GroupedByAddend && GroupHasAddend)
421 Addend +=
Data.getSLEB128(Cur);
426 for (
uint64_t I = 0; Cur &&
I != NumRelocsInGroup; ++
I) {
428 Offset += GroupedByOffsetDelta ? GroupOffsetDelta :
Data.getSLEB128(Cur);
430 R.r_info = GroupedByInfo ? GroupRInfo :
Data.getSLEB128(Cur);
431 if (GroupHasAddend && !GroupedByAddend)
432 Addend +=
Data.getSLEB128(Cur);
443 template <
class ELFT>
446 #define DYNAMIC_STRINGIFY_ENUM(tag, value) \
450 #define DYNAMIC_TAG(n, v)
454 #define AARCH64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
455 #include "llvm/BinaryFormat/DynamicTags.def"
456 #undef AARCH64_DYNAMIC_TAG
462 #define HEXAGON_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
463 #include "llvm/BinaryFormat/DynamicTags.def"
464 #undef HEXAGON_DYNAMIC_TAG
470 #define MIPS_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
471 #include "llvm/BinaryFormat/DynamicTags.def"
472 #undef MIPS_DYNAMIC_TAG
478 #define PPC_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
479 #include "llvm/BinaryFormat/DynamicTags.def"
480 #undef PPC_DYNAMIC_TAG
486 #define PPC64_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
487 #include "llvm/BinaryFormat/DynamicTags.def"
488 #undef PPC64_DYNAMIC_TAG
494 #define RISCV_DYNAMIC_TAG(name, value) DYNAMIC_STRINGIFY_ENUM(name, value)
495 #include "llvm/BinaryFormat/DynamicTags.def"
496 #undef RISCV_DYNAMIC_TAG
503 #define AARCH64_DYNAMIC_TAG(name, value)
504 #define MIPS_DYNAMIC_TAG(name, value)
505 #define HEXAGON_DYNAMIC_TAG(name, value)
506 #define PPC_DYNAMIC_TAG(name, value)
507 #define PPC64_DYNAMIC_TAG(name, value)
508 #define RISCV_DYNAMIC_TAG(name, value)
510 #define DYNAMIC_TAG_MARKER(name, value)
511 #define DYNAMIC_TAG(name, value) case value: return #name;
512 #include "llvm/BinaryFormat/DynamicTags.def"
514 #undef AARCH64_DYNAMIC_TAG
515 #undef MIPS_DYNAMIC_TAG
516 #undef HEXAGON_DYNAMIC_TAG
517 #undef PPC_DYNAMIC_TAG
518 #undef PPC64_DYNAMIC_TAG
519 #undef RISCV_DYNAMIC_TAG
520 #undef DYNAMIC_TAG_MARKER
521 #undef DYNAMIC_STRINGIFY_ENUM
523 return "<unknown:>0x" + utohexstr(
Type,
true);
527 template <
class ELFT>
529 return getDynamicTagAsString(getHeader().e_machine,
Type);
532 template <
class ELFT>
536 auto ProgramHeadersOrError = program_headers();
537 if (!ProgramHeadersOrError)
538 return ProgramHeadersOrError.takeError();
540 for (
const Elf_Phdr &Phdr : *ProgramHeadersOrError) {
543 reinterpret_cast<const Elf_Dyn *
>(
base() + Phdr.p_offset),
544 Phdr.p_filesz /
sizeof(Elf_Dyn));
552 auto SectionsOrError = sections();
553 if (!SectionsOrError)
554 return SectionsOrError.takeError();
556 for (
const Elf_Shdr &Sec : *SectionsOrError) {
559 getSectionContentsAsArray<Elf_Dyn>(Sec);
572 return createError(
"invalid empty dynamic section");
574 if (Dyn.
back().d_tag != ELF::DT_NULL)
575 return createError(
"dynamic sections must be DT_NULL terminated");
580 template <
class ELFT>
583 auto ProgramHeadersOrError = program_headers();
584 if (!ProgramHeadersOrError)
585 return ProgramHeadersOrError.takeError();
589 for (
const Elf_Phdr &Phdr : *ProgramHeadersOrError)
591 LoadSegments.push_back(
const_cast<Elf_Phdr *
>(&Phdr));
595 return A->p_vaddr <
B->p_vaddr;
599 WarnHandler(
"loadable segments are unsorted by virtual address"))
606 return VAddr < Phdr->p_vaddr;
609 if (
I == LoadSegments.begin())
610 return createError(
"virtual address is not in any segment: 0x" +
613 const Elf_Phdr &Phdr = **
I;
614 uint64_t Delta = VAddr - Phdr.p_vaddr;
615 if (Delta >= Phdr.p_filesz)
616 return createError(
"virtual address is not in any segment: 0x" +
619 uint64_t Offset = Phdr.p_offset + Delta;
620 if (Offset >= getBufSize())
621 return createError(
"can't map virtual address 0x" +
623 Twine(&Phdr - (*ProgramHeadersOrError).data() + 1) +
624 ": the segment ends at 0x" +
626 ", which is greater than the file size (0x" +
629 return base() + Offset;
632 template <
class ELFT>
640 std::vector<BBAddrMap> FunctionEntries;
648 auto ReadULEB128AsUInt32 = [&
Data, &Cur, &ULEBSizeErr]() ->
uint32_t {
654 if (
Value > UINT32_MAX) {
664 while (!ULEBSizeErr && Cur && Cur.tell() <
Content.size()) {
670 return createError(
"unsupported SHT_LLVM_BB_ADDR_MAP version: " +
674 uintX_t Address =
static_cast<uintX_t
>(
Data.getAddress(Cur));
675 uint32_t NumBlocks = ReadULEB128AsUInt32();
676 std::vector<BBAddrMap::BBEntry> BBEntries;
678 for (
uint32_t BlockID = 0; !ULEBSizeErr && Cur && (BlockID < NumBlocks);
680 uint32_t Offset = ReadULEB128AsUInt32();
681 uint32_t Size = ReadULEB128AsUInt32();
685 Offset += PrevBBEndOffset;
686 PrevBBEndOffset = Offset + Size;
688 BBEntries.push_back({Offset, Size,
Metadata});
690 FunctionEntries.push_back({Address,
std::move(BBEntries)});
694 if (!Cur || ULEBSizeErr)
696 return FunctionEntries;