void MappingTraits<MachOYAML::UniversalBinary>::mapping(
IO &IO, MachOYAML::UniversalBinary &UniversalBinary) {
if (!IO.getContext()) {
IO.setContext(&UniversalBinary);
IO.mapTag("!fat-mach-o", true);
}
IO.mapRequired("FatHeader", UniversalBinary.Header);
IO.mapRequired("FatArchs", UniversalBinary.FatArchs);
IO.mapRequired("Slices", UniversalBinary.Slices);
if (IO.getContext() == &UniversalBinary)
IO.setContext(nullptr);
}
void MappingTraits<MachOYAML::Object>::mapping(IO &IO,
MachOYAML::Object &Object) {
// If the context isn't already set, tag the document as !mach-o.
// For Fat files there will be a different tag so they can be differentiated.
if (!IO.getContext()) {
IO.setContext(&Object);
}
IO.mapTag("!mach-o", true);
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("LoadCommands", Object.LoadCommands);
IO.mapOptional("LinkEditData", Object.LinkEdit);
if (IO.getContext() == &Object)
IO.setContext(nullptr);
}
void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
IO &IO, ELFYAML::ELF_SHT &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHT_NULL);
ECase(SHT_PROGBITS);
ECase(SHT_SYMTAB);
// FIXME: Issue a diagnostic with this information.
ECase(SHT_STRTAB);
ECase(SHT_RELA);
ECase(SHT_HASH);
ECase(SHT_DYNAMIC);
ECase(SHT_NOTE);
ECase(SHT_NOBITS);
ECase(SHT_REL);
ECase(SHT_SHLIB);
ECase(SHT_DYNSYM);
ECase(SHT_INIT_ARRAY);
ECase(SHT_FINI_ARRAY);
ECase(SHT_PREINIT_ARRAY);
ECase(SHT_GROUP);
ECase(SHT_SYMTAB_SHNDX);
ECase(SHT_LOOS);
ECase(SHT_ANDROID_REL);
ECase(SHT_ANDROID_RELA);
ECase(SHT_LLVM_ODRTAB);
ECase(SHT_LLVM_LINKER_OPTIONS);
ECase(SHT_GNU_ATTRIBUTES);
ECase(SHT_GNU_HASH);
ECase(SHT_GNU_verdef);
ECase(SHT_GNU_verneed);
ECase(SHT_GNU_versym);
ECase(SHT_HIOS);
ECase(SHT_LOPROC);
switch (Object->Header.Machine) {
case ELF::EM_ARM:
ECase(SHT_ARM_EXIDX);
ECase(SHT_ARM_PREEMPTMAP);
ECase(SHT_ARM_ATTRIBUTES);
ECase(SHT_ARM_DEBUGOVERLAY);
ECase(SHT_ARM_OVERLAYSECTION);
break;
case ELF::EM_HEXAGON:
ECase(SHT_HEX_ORDERED);
break;
case ELF::EM_X86_64:
ECase(SHT_X86_64_UNWIND);
break;
case ELF::EM_MIPS:
ECase(SHT_MIPS_REGINFO);
ECase(SHT_MIPS_OPTIONS);
ECase(SHT_MIPS_ABIFLAGS);
break;
default:
// Nothing to do.
break;
}
#undef ECase
}
void MappingTraits<DWARFYAML::PubEntry>::mapping(IO &IO,
DWARFYAML::PubEntry &Entry) {
IO.mapRequired("DieOffset", Entry.DieOffset);
if (reinterpret_cast<DWARFYAML::PubSection *>(IO.getContext())->IsGNUStyle)
IO.mapRequired("Descriptor", Entry.Descriptor);
IO.mapRequired("Name", Entry.Name);
}
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
assert(!IO.getContext() && "The IO context is initialized already");
IO.setContext(&Object);
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("Sections", Object.Sections);
IO.mapOptional("Symbols", Object.Symbols);
IO.setContext(nullptr);
}
static void mapping(IO &io, SourceLoc &Loc) {
assert(io.outputting() && "input not yet implemented");
SourceManager *SM = static_cast<SourceManager *>(io.getContext());
StringRef File = SM->getDisplayNameForLoc(Loc);
unsigned Line, Col;
std::tie(Line, Col) = SM->getLineAndColumn(Loc);
io.mapRequired("File", File);
io.mapRequired("Line", Line);
io.mapRequired("Column", Col);
}
ArrayRef<uint8_t> denormalize(IO &io) {
// When reading yaml, allocate byte array owned by NormalizedFile and
// copy Hex8 vector to byte array.
YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
assert(info != nullptr);
NormalizedFile *file = info->_normalizeMachOFile;
assert(file != nullptr);
size_t size = _normalizedContent.size();
uint8_t *bytes = file->ownedAllocations.Allocate<uint8_t>(size);
std::copy(_normalizedContent.begin(), _normalizedContent.end(), bytes);
return makeArrayRef(bytes, size);
}
void MappingTraits<DWARFYAML::PubSection>::mapping(
IO &IO, DWARFYAML::PubSection &Section) {
auto OldContext = IO.getContext();
IO.setContext(&Section);
IO.mapRequired("Length", Section.Length);
IO.mapRequired("Version", Section.Version);
IO.mapRequired("UnitOffset", Section.UnitOffset);
IO.mapRequired("UnitSize", Section.UnitSize);
IO.mapRequired("Entries", Section.Entries);
IO.setContext(OldContext);
}
void MappingTraits<MachOYAML::Object>::mapping(IO &IO,
MachOYAML::Object &Object) {
// If the context isn't already set, tag the document as !mach-o.
// For Fat files there will be a different tag so they can be differentiated.
if (!IO.getContext()) {
IO.setContext(&Object);
}
IO.mapTag("!mach-o", true);
IO.mapOptional("IsLittleEndian", Object.IsLittleEndian,
sys::IsLittleEndianHost);
Object.DWARF.IsLittleEndian = Object.IsLittleEndian;
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("LoadCommands", Object.LoadCommands);
if(!Object.LinkEdit.isEmpty() || !IO.outputting())
IO.mapOptional("LinkEditData", Object.LinkEdit);
if(!Object.DWARF.isEmpty() || !IO.outputting())
IO.mapOptional("DWARF", Object.DWARF);
if (IO.getContext() == &Object)
IO.setContext(nullptr);
}
void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
IO &IO, ELFYAML::ELF_REL &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
switch (Object->Header.Machine) {
case ELF::EM_X86_64:
#include "llvm/BinaryFormat/ELFRelocs/x86_64.def"
break;
case ELF::EM_MIPS:
#include "llvm/BinaryFormat/ELFRelocs/Mips.def"
break;
case ELF::EM_HEXAGON:
#include "llvm/BinaryFormat/ELFRelocs/Hexagon.def"
break;
case ELF::EM_386:
case ELF::EM_IAMCU:
#include "llvm/BinaryFormat/ELFRelocs/i386.def"
break;
case ELF::EM_AARCH64:
#include "llvm/BinaryFormat/ELFRelocs/AArch64.def"
break;
case ELF::EM_ARM:
#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
break;
case ELF::EM_ARC:
#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
break;
case ELF::EM_RISCV:
#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
break;
case ELF::EM_LANAI:
#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
break;
case ELF::EM_AMDGPU:
#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
break;
case ELF::EM_BPF:
#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
break;
default:
llvm_unreachable("Unsupported architecture");
}
#undef ELF_RELOC
IO.enumFallback<Hex32>(Value);
}
void ScalarBitSetTraits<ELFYAML::ELF_STO>::bitset(IO &IO,
ELFYAML::ELF_STO &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
switch (Object->Header.Machine) {
case ELF::EM_MIPS:
BCase(STO_MIPS_OPTIONAL);
BCase(STO_MIPS_PLT);
BCase(STO_MIPS_PIC);
BCase(STO_MIPS_MICROMIPS);
break;
default:
break; // Nothing to do
}
#undef BCase
#undef BCaseMask
}
void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(SHF_WRITE);
BCase(SHF_ALLOC);
BCase(SHF_EXCLUDE);
BCase(SHF_EXECINSTR);
BCase(SHF_MERGE);
BCase(SHF_STRINGS);
BCase(SHF_INFO_LINK);
BCase(SHF_LINK_ORDER);
BCase(SHF_OS_NONCONFORMING);
BCase(SHF_GROUP);
BCase(SHF_TLS);
BCase(SHF_COMPRESSED);
switch (Object->Header.Machine) {
case ELF::EM_ARM:
BCase(SHF_ARM_PURECODE);
break;
case ELF::EM_HEXAGON:
BCase(SHF_HEX_GPREL);
break;
case ELF::EM_MIPS:
BCase(SHF_MIPS_NODUPES);
BCase(SHF_MIPS_NAMES);
BCase(SHF_MIPS_LOCAL);
BCase(SHF_MIPS_NOSTRIP);
BCase(SHF_MIPS_GPREL);
BCase(SHF_MIPS_MERGE);
BCase(SHF_MIPS_ADDR);
BCase(SHF_MIPS_STRING);
break;
case ELF::EM_X86_64:
BCase(SHF_X86_64_LARGE);
break;
default:
// Nothing to do.
break;
}
#undef BCase
}
void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
ELFYAML::ELF_EF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M)
switch (Object->Header.Machine) {
case ELF::EM_ARM:
BCase(EF_ARM_SOFT_FLOAT);
BCase(EF_ARM_VFP_FLOAT);
BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK);
BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK);
break;
case ELF::EM_MIPS:
BCase(EF_MIPS_NOREORDER);
BCase(EF_MIPS_PIC);
BCase(EF_MIPS_CPIC);
BCase(EF_MIPS_ABI2);
BCase(EF_MIPS_32BITMODE);
BCase(EF_MIPS_FP64);
BCase(EF_MIPS_NAN2008);
BCase(EF_MIPS_MICROMIPS);
BCase(EF_MIPS_ARCH_ASE_M16);
BCase(EF_MIPS_ARCH_ASE_MDMX);
BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI);
BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI);
BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH);
BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH);
BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH);
BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH);
break;
case ELF::EM_HEXAGON:
BCase(EF_HEXAGON_MACH_V2);
BCase(EF_HEXAGON_MACH_V3);
BCase(EF_HEXAGON_MACH_V4);
BCase(EF_HEXAGON_MACH_V5);
BCase(EF_HEXAGON_ISA_V2);
BCase(EF_HEXAGON_ISA_V3);
BCase(EF_HEXAGON_ISA_V4);
BCase(EF_HEXAGON_ISA_V5);
break;
case ELF::EM_AVR:
BCase(EF_AVR_ARCH_AVR1);
BCase(EF_AVR_ARCH_AVR2);
BCase(EF_AVR_ARCH_AVR25);
BCase(EF_AVR_ARCH_AVR3);
BCase(EF_AVR_ARCH_AVR31);
BCase(EF_AVR_ARCH_AVR35);
BCase(EF_AVR_ARCH_AVR4);
BCase(EF_AVR_ARCH_AVR51);
BCase(EF_AVR_ARCH_AVR6);
BCase(EF_AVR_ARCH_AVRTINY);
BCase(EF_AVR_ARCH_XMEGA1);
BCase(EF_AVR_ARCH_XMEGA2);
BCase(EF_AVR_ARCH_XMEGA3);
BCase(EF_AVR_ARCH_XMEGA4);
BCase(EF_AVR_ARCH_XMEGA5);
BCase(EF_AVR_ARCH_XMEGA6);
BCase(EF_AVR_ARCH_XMEGA7);
break;
case ELF::EM_RISCV:
BCase(EF_RISCV_RVC);
BCaseMask(EF_RISCV_FLOAT_ABI_SOFT, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_SINGLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_DOUBLE, EF_RISCV_FLOAT_ABI);
BCaseMask(EF_RISCV_FLOAT_ABI_QUAD, EF_RISCV_FLOAT_ABI);
BCase(EF_RISCV_RVE);
break;
case ELF::EM_AMDGPU:
BCaseMask(EF_AMDGPU_ARCH_R600, EF_AMDGPU_ARCH);
BCaseMask(EF_AMDGPU_ARCH_GCN, EF_AMDGPU_ARCH);
break;
case ELF::EM_X86_64:
break;
default:
llvm_unreachable("Unsupported architecture");
}
#undef BCase
#undef BCaseMask
}
static void enumeration(IO &io, RelocationInfoType &value) {
YamlContext *info = reinterpret_cast<YamlContext *>(io.getContext());
assert(info != nullptr);
NormalizedFile *file = info->_normalizeMachOFile;
assert(file != nullptr);
switch (file->arch) {
case lld::MachOLinkingContext::arch_x86_64:
io.enumCase(value, "X86_64_RELOC_UNSIGNED",
llvm::MachO::X86_64_RELOC_UNSIGNED);
io.enumCase(value, "X86_64_RELOC_SIGNED",
llvm::MachO::X86_64_RELOC_SIGNED);
io.enumCase(value, "X86_64_RELOC_BRANCH",
llvm::MachO::X86_64_RELOC_BRANCH);
io.enumCase(value, "X86_64_RELOC_GOT_LOAD",
llvm::MachO::X86_64_RELOC_GOT_LOAD);
io.enumCase(value, "X86_64_RELOC_GOT",
llvm::MachO::X86_64_RELOC_GOT);
io.enumCase(value, "X86_64_RELOC_SUBTRACTOR",
llvm::MachO::X86_64_RELOC_SUBTRACTOR);
io.enumCase(value, "X86_64_RELOC_SIGNED_1",
llvm::MachO::X86_64_RELOC_SIGNED_1);
io.enumCase(value, "X86_64_RELOC_SIGNED_2",
llvm::MachO::X86_64_RELOC_SIGNED_2);
io.enumCase(value, "X86_64_RELOC_SIGNED_4",
llvm::MachO::X86_64_RELOC_SIGNED_4);
io.enumCase(value, "X86_64_RELOC_TLV",
llvm::MachO::X86_64_RELOC_TLV);
break;
case lld::MachOLinkingContext::arch_x86:
io.enumCase(value, "GENERIC_RELOC_VANILLA",
llvm::MachO::GENERIC_RELOC_VANILLA);
io.enumCase(value, "GENERIC_RELOC_PAIR",
llvm::MachO::GENERIC_RELOC_PAIR);
io.enumCase(value, "GENERIC_RELOC_SECTDIFF",
llvm::MachO::GENERIC_RELOC_SECTDIFF);
io.enumCase(value, "GENERIC_RELOC_LOCAL_SECTDIFF",
llvm::MachO::GENERIC_RELOC_LOCAL_SECTDIFF);
io.enumCase(value, "GENERIC_RELOC_TLV",
llvm::MachO::GENERIC_RELOC_TLV);
break;
case lld::MachOLinkingContext::arch_armv6:
case lld::MachOLinkingContext::arch_armv7:
case lld::MachOLinkingContext::arch_armv7s:
io.enumCase(value, "ARM_RELOC_VANILLA",
llvm::MachO::ARM_RELOC_VANILLA);
io.enumCase(value, "ARM_RELOC_PAIR",
llvm::MachO::ARM_RELOC_PAIR);
io.enumCase(value, "ARM_RELOC_SECTDIFF",
llvm::MachO::ARM_RELOC_SECTDIFF);
io.enumCase(value, "ARM_RELOC_LOCAL_SECTDIFF",
llvm::MachO::ARM_RELOC_LOCAL_SECTDIFF);
io.enumCase(value, "ARM_RELOC_BR24",
llvm::MachO::ARM_RELOC_BR24);
io.enumCase(value, "ARM_THUMB_RELOC_BR22",
llvm::MachO::ARM_THUMB_RELOC_BR22);
io.enumCase(value, "ARM_RELOC_HALF",
llvm::MachO::ARM_RELOC_HALF);
io.enumCase(value, "ARM_RELOC_HALF_SECTDIFF",
llvm::MachO::ARM_RELOC_HALF_SECTDIFF);
break;
case lld::MachOLinkingContext::arch_arm64:
io.enumCase(value, "ARM64_RELOC_UNSIGNED",
llvm::MachO::ARM64_RELOC_UNSIGNED);
io.enumCase(value, "ARM64_RELOC_SUBTRACTOR",
llvm::MachO::ARM64_RELOC_SUBTRACTOR);
io.enumCase(value, "ARM64_RELOC_BRANCH26",
llvm::MachO::ARM64_RELOC_BRANCH26);
io.enumCase(value, "ARM64_RELOC_PAGE21",
llvm::MachO::ARM64_RELOC_PAGE21);
io.enumCase(value, "ARM64_RELOC_PAGEOFF12",
llvm::MachO::ARM64_RELOC_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_GOT_LOAD_PAGE21",
llvm::MachO::ARM64_RELOC_GOT_LOAD_PAGE21);
io.enumCase(value, "ARM64_RELOC_GOT_LOAD_PAGEOFF12",
llvm::MachO::ARM64_RELOC_GOT_LOAD_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_POINTER_TO_GOT",
llvm::MachO::ARM64_RELOC_POINTER_TO_GOT);
io.enumCase(value, "ARM64_RELOC_TLVP_LOAD_PAGE21",
llvm::MachO::ARM64_RELOC_TLVP_LOAD_PAGE21);
io.enumCase(value, "ARM64_RELOC_TLVP_LOAD_PAGEOFF12",
llvm::MachO::ARM64_RELOC_TLVP_LOAD_PAGEOFF12);
io.enumCase(value, "ARM64_RELOC_ADDEND",
llvm::MachO::ARM64_RELOC_ADDEND);
break;
default:
llvm_unreachable("unknown architecture");
}
}
