RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-23 19:23:23 +01:00
Code Issues Projects Releases Wiki Activity
c29f69e247
llvm-mirror/lib/Object/ELFYAML.cpp

777 lines
22 KiB
C++
Raw Normal View History

[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
//===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of ELF.
//
//===----------------------------------------------------------------------===//
#include "llvm/Object/ELFYAML.h"
raw_ostream: Forward declare OpenFlags and include FileSystem.h only where necessary. llvm-svn: 207593
2014-04-30 01:26:49 +02:00
#include "llvm/Support/Casting.h"
[obj2yaml/yaml2obj] Add SHT_MIPS_ABIFLAGS section support This change adds support for the SHT_MIPS_ABIFLAGS section reading/writing to the obj2yaml and yaml2obj tools. llvm-svn: 236738
2015-05-07 17:40:48 +02:00
#include "llvm/Support/MipsABIFlags.h"
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
namespace llvm {
[yaml2obj][ELF] Add a virtual destructor to the ELFYAML::Section class to prevent memory leaks. llvm-svn: 206969
2014-04-23 13:10:55 +02:00
[yaml2obj][ELF] Remove unnecessary space between namespace name and colons. llvm-svn: 207003
2014-04-23 19:30:29 +02:00
ELFYAML::Section::~Section() {}
[yaml2obj][ELF] Add a virtual destructor to the ELFYAML::Section class to prevent memory leaks. llvm-svn: 206969
2014-04-23 13:10:55 +02:00
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
namespace yaml {
void
ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(IO &IO,
ELFYAML::ELF_ET &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(ET_NONE)
ECase(ET_REL)
ECase(ET_EXEC)
ECase(ET_DYN)
ECase(ET_CORE)
#undef ECase
[Object][ELF] Test unknown type. llvm-svn: 226943
2015-01-23 22:58:09 +01:00
IO.enumFallback<Hex16>(Value);
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
}
void
ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(IO &IO,
ELFYAML::ELF_EM &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(EM_NONE)
ECase(EM_M32)
ECase(EM_SPARC)
ECase(EM_386)
ECase(EM_68K)
ECase(EM_88K)
Fix the build. Sorry, I have no idea how grep failed to find this. llvm-svn: 240133
2015-06-19 16:34:12 +02:00
ECase(EM_IAMCU)
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
ECase(EM_860)
ECase(EM_MIPS)
ECase(EM_S370)
ECase(EM_MIPS_RS3_LE)
ECase(EM_PARISC)
ECase(EM_VPP500)
ECase(EM_SPARC32PLUS)
ECase(EM_960)
ECase(EM_PPC)
ECase(EM_PPC64)
ECase(EM_S390)
ECase(EM_SPU)
ECase(EM_V800)
ECase(EM_FR20)
ECase(EM_RH32)
ECase(EM_RCE)
ECase(EM_ARM)
ECase(EM_ALPHA)
ECase(EM_SH)
ECase(EM_SPARCV9)
ECase(EM_TRICORE)
ECase(EM_ARC)
ECase(EM_H8_300)
ECase(EM_H8_300H)
ECase(EM_H8S)
ECase(EM_H8_500)
ECase(EM_IA_64)
ECase(EM_MIPS_X)
ECase(EM_COLDFIRE)
ECase(EM_68HC12)
ECase(EM_MMA)
ECase(EM_PCP)
ECase(EM_NCPU)
ECase(EM_NDR1)
ECase(EM_STARCORE)
ECase(EM_ME16)
ECase(EM_ST100)
ECase(EM_TINYJ)
ECase(EM_X86_64)
ECase(EM_PDSP)
ECase(EM_PDP10)
ECase(EM_PDP11)
ECase(EM_FX66)
ECase(EM_ST9PLUS)
ECase(EM_ST7)
ECase(EM_68HC16)
ECase(EM_68HC11)
ECase(EM_68HC08)
ECase(EM_68HC05)
ECase(EM_SVX)
ECase(EM_ST19)
ECase(EM_VAX)
ECase(EM_CRIS)
ECase(EM_JAVELIN)
ECase(EM_FIREPATH)
ECase(EM_ZSP)
ECase(EM_MMIX)
ECase(EM_HUANY)
ECase(EM_PRISM)
ECase(EM_AVR)
ECase(EM_FR30)
ECase(EM_D10V)
ECase(EM_D30V)
ECase(EM_V850)
ECase(EM_M32R)
ECase(EM_MN10300)
ECase(EM_MN10200)
ECase(EM_PJ)
ECase(EM_OPENRISC)
ECase(EM_ARC_COMPACT)
ECase(EM_XTENSA)
ECase(EM_VIDEOCORE)
ECase(EM_TMM_GPP)
ECase(EM_NS32K)
ECase(EM_TPC)
ECase(EM_SNP1K)
ECase(EM_ST200)
ECase(EM_IP2K)
ECase(EM_MAX)
ECase(EM_CR)
ECase(EM_F2MC16)
ECase(EM_MSP430)
ECase(EM_BLACKFIN)
ECase(EM_SE_C33)
ECase(EM_SEP)
ECase(EM_ARCA)
ECase(EM_UNICORE)
ECase(EM_EXCESS)
ECase(EM_DXP)
ECase(EM_ALTERA_NIOS2)
ECase(EM_CRX)
ECase(EM_XGATE)
ECase(EM_C166)
ECase(EM_M16C)
ECase(EM_DSPIC30F)
ECase(EM_CE)
ECase(EM_M32C)
ECase(EM_TSK3000)
ECase(EM_RS08)
ECase(EM_SHARC)
ECase(EM_ECOG2)
ECase(EM_SCORE7)
ECase(EM_DSP24)
ECase(EM_VIDEOCORE3)
ECase(EM_LATTICEMICO32)
ECase(EM_SE_C17)
ECase(EM_TI_C6000)
ECase(EM_TI_C2000)
ECase(EM_TI_C5500)
ECase(EM_MMDSP_PLUS)
ECase(EM_CYPRESS_M8C)
ECase(EM_R32C)
ECase(EM_TRIMEDIA)
ECase(EM_HEXAGON)
ECase(EM_8051)
ECase(EM_STXP7X)
ECase(EM_NDS32)
ECase(EM_ECOG1)
ECase(EM_ECOG1X)
ECase(EM_MAXQ30)
ECase(EM_XIMO16)
ECase(EM_MANIK)
ECase(EM_CRAYNV2)
ECase(EM_RX)
ECase(EM_METAG)
ECase(EM_MCST_ELBRUS)
ECase(EM_ECOG16)
ECase(EM_CR16)
ECase(EM_ETPU)
ECase(EM_SLE9X)
ECase(EM_L10M)
ECase(EM_K10M)
ECase(EM_AARCH64)
ECase(EM_AVR32)
ECase(EM_STM8)
ECase(EM_TILE64)
ECase(EM_TILEPRO)
ECase(EM_CUDA)
ECase(EM_TILEGX)
ECase(EM_CLOUDSHIELD)
ECase(EM_COREA_1ST)
ECase(EM_COREA_2ND)
ECase(EM_ARC_COMPACT2)
ECase(EM_OPEN8)
ECase(EM_RL78)
ECase(EM_VIDEOCORE5)
ECase(EM_78KOR)
ECase(EM_56800EX)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
// here.
ECase(ELFCLASS32)
ECase(ELFCLASS64)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
IO &IO, ELFYAML::ELF_ELFDATA &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
// Since the semantics of ELFDATANONE is "invalid", just don't accept it
// here.
ECase(ELFDATA2LSB)
ECase(ELFDATA2MSB)
#undef ECase
}
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 02:55:28 +02:00
void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(ELFOSABI_NONE)
ECase(ELFOSABI_HPUX)
ECase(ELFOSABI_NETBSD)
ECase(ELFOSABI_GNU)
ECase(ELFOSABI_GNU)
ECase(ELFOSABI_HURD)
ECase(ELFOSABI_SOLARIS)
ECase(ELFOSABI_AIX)
ECase(ELFOSABI_IRIX)
ECase(ELFOSABI_FREEBSD)
ECase(ELFOSABI_TRU64)
ECase(ELFOSABI_MODESTO)
ECase(ELFOSABI_OPENBSD)
ECase(ELFOSABI_OPENVMS)
ECase(ELFOSABI_NSK)
ECase(ELFOSABI_AROS)
ECase(ELFOSABI_FENIXOS)
Add support for Nuxi CloudABI. CloudABI is a POSIX-like runtime environment built around the concept of capability-based security. More details: https://github.com/NuxiNL/cloudlibc CloudABI uses its own ELFOSABI number. This number has been allocated by the maintainers of ELF a couple of days ago. Reviewed by: echristo llvm-svn: 231681
2015-03-09 19:40:45 +01:00
ECase(ELFOSABI_CLOUDABI)
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 02:55:28 +02:00
ECase(ELFOSABI_C6000_ELFABI)
ECase(ELFOSABI_C6000_LINUX)
ECase(ELFOSABI_ARM)
ECase(ELFOSABI_STANDALONE)
#undef ECase
}
[yaml2obj] Add support for ELF e_flags. Summary: The FileHeader mapping now accepts an optional Flags sequence that accepts the EF_<arch>_<flag> constants. When not given, Flags defaults to zero. Reviewers: atanasyan Reviewed By: atanasyan CC: llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D3213 llvm-svn: 205173
2014-03-31 11:44:05 +02:00
void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
ELFYAML::ELF_EF &Value) {
[ELFYAML] Group ELF header falgs to target specific blocks. Handle flags which are corresponding to the current target read from the ELF file. This fix cannot be tested until obj2yaml does not support ELF format. llvm-svn: 207905
2014-05-03 13:39:50 +02:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
[yaml2obj] Add support for ELF e_flags. Summary: The FileHeader mapping now accepts an optional Flags sequence that accepts the EF_<arch>_<flag> constants. When not given, Flags defaults to zero. Reviewers: atanasyan Reviewed By: atanasyan CC: llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D3213 llvm-svn: 205173
2014-03-31 11:44:05 +02:00
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
[YAML] Add an optional argument `EnumMask` to the `yaml::IO::bitSetCase()`. Some bit-set fields used in ELF file headers in fact contain two parts. The first one is a regular bit-field. The second one is an enumeraion. For example ELF header `e_flags` for MIPS target might contain the following values: Bit-set values: EF_MIPS_NOREORDER = 0x00000001 EF_MIPS_PIC = 0x00000002 EF_MIPS_CPIC = 0x00000004 EF_MIPS_ABI2 = 0x00000020 Enumeration: EF_MIPS_ARCH_32 = 0x50000000 EF_MIPS_ARCH_64 = 0x60000000 EF_MIPS_ARCH_32R2 = 0x70000000 EF_MIPS_ARCH_64R2 = 0x80000000 For printing bit-sets we use the `yaml::IO::bitSetCase()`. It does not support bit-set/enumeration combinations and prints too many flags from an enumeration part. This patch fixes this problem. New method `yaml::IO::maskedBitSetCase()` handle "enumeration" part of bitset defined by provided mask. Patch reviewed by Nick Kledzik and Sean Silva. llvm-svn: 209504
2014-05-23 10:07:09 +02:00
#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M);
[ELFYAML] Group ELF header falgs to target specific blocks. Handle flags which are corresponding to the current target read from the ELF file. This fix cannot be tested until obj2yaml does not support ELF format. llvm-svn: 207905
2014-05-03 13:39:50 +02:00
switch (Object->Header.Machine) {
case ELF::EM_ARM:
BCase(EF_ARM_SOFT_FLOAT)
BCase(EF_ARM_VFP_FLOAT)
[YAML] Add an optional argument `EnumMask` to the `yaml::IO::bitSetCase()`. Some bit-set fields used in ELF file headers in fact contain two parts. The first one is a regular bit-field. The second one is an enumeraion. For example ELF header `e_flags` for MIPS target might contain the following values: Bit-set values: EF_MIPS_NOREORDER = 0x00000001 EF_MIPS_PIC = 0x00000002 EF_MIPS_CPIC = 0x00000004 EF_MIPS_ABI2 = 0x00000020 Enumeration: EF_MIPS_ARCH_32 = 0x50000000 EF_MIPS_ARCH_64 = 0x60000000 EF_MIPS_ARCH_32R2 = 0x70000000 EF_MIPS_ARCH_64R2 = 0x80000000 For printing bit-sets we use the `yaml::IO::bitSetCase()`. It does not support bit-set/enumeration combinations and prints too many flags from an enumeration part. This patch fixes this problem. New method `yaml::IO::maskedBitSetCase()` handle "enumeration" part of bitset defined by provided mask. Patch reviewed by Nick Kledzik and Sean Silva. llvm-svn: 209504
2014-05-23 10:07:09 +02:00
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)
[ELFYAML] Group ELF header falgs to target specific blocks. Handle flags which are corresponding to the current target read from the ELF file. This fix cannot be tested until obj2yaml does not support ELF format. llvm-svn: 207905
2014-05-03 13:39:50 +02:00
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)
[llvm-readobj/obj2yaml/yaml2obj] Support more MIPS ELF header flags llvm-svn: 236728
2015-05-07 16:04:44 +02:00
BCase(EF_MIPS_FP64)
[yaml2obj] Allow yaml2obj tool to recognize EF_MIPS_NAN2008 flag llvm-svn: 221268
2014-11-04 14:33:36 +01:00
BCase(EF_MIPS_NAN2008)
[ELFYAML] Group ELF header falgs to target specific blocks. Handle flags which are corresponding to the current target read from the ELF file. This fix cannot be tested until obj2yaml does not support ELF format. llvm-svn: 207905
2014-05-03 13:39:50 +02:00
BCase(EF_MIPS_MICROMIPS)
BCase(EF_MIPS_ARCH_ASE_M16)
[llvm-readobj/obj2yaml/yaml2obj] Support more MIPS ELF header flags llvm-svn: 236728
2015-05-07 16:04:44 +02:00
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)
[llvm-readobj/obj2yaml/yaml2obj] Support MIPS machine ELF header flags llvm-svn: 236807
2015-05-08 09:04:59 +02:00
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)
[YAML] Add an optional argument `EnumMask` to the `yaml::IO::bitSetCase()`. Some bit-set fields used in ELF file headers in fact contain two parts. The first one is a regular bit-field. The second one is an enumeraion. For example ELF header `e_flags` for MIPS target might contain the following values: Bit-set values: EF_MIPS_NOREORDER = 0x00000001 EF_MIPS_PIC = 0x00000002 EF_MIPS_CPIC = 0x00000004 EF_MIPS_ABI2 = 0x00000020 Enumeration: EF_MIPS_ARCH_32 = 0x50000000 EF_MIPS_ARCH_64 = 0x60000000 EF_MIPS_ARCH_32R2 = 0x70000000 EF_MIPS_ARCH_64R2 = 0x80000000 For printing bit-sets we use the `yaml::IO::bitSetCase()`. It does not support bit-set/enumeration combinations and prints too many flags from an enumeration part. This patch fixes this problem. New method `yaml::IO::maskedBitSetCase()` handle "enumeration" part of bitset defined by provided mask. Patch reviewed by Nick Kledzik and Sean Silva. llvm-svn: 209504
2014-05-23 10:07:09 +02:00
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)
[ELFYAML] Group ELF header falgs to target specific blocks. Handle flags which are corresponding to the current target read from the ELF file. This fix cannot be tested until obj2yaml does not support ELF format. llvm-svn: 207905
2014-05-03 13:39:50 +02:00
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;
default:
llvm_unreachable("Unsupported architecture");
}
[yaml2obj] Add support for ELF e_flags. Summary: The FileHeader mapping now accepts an optional Flags sequence that accepts the EF_<arch>_<flag> constants. When not given, Flags defaults to zero. Reviewers: atanasyan Reviewed By: atanasyan CC: llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D3213 llvm-svn: 205173
2014-03-31 11:44:05 +02:00
#undef BCase
[YAML] Add an optional argument `EnumMask` to the `yaml::IO::bitSetCase()`. Some bit-set fields used in ELF file headers in fact contain two parts. The first one is a regular bit-field. The second one is an enumeraion. For example ELF header `e_flags` for MIPS target might contain the following values: Bit-set values: EF_MIPS_NOREORDER = 0x00000001 EF_MIPS_PIC = 0x00000002 EF_MIPS_CPIC = 0x00000004 EF_MIPS_ABI2 = 0x00000020 Enumeration: EF_MIPS_ARCH_32 = 0x50000000 EF_MIPS_ARCH_64 = 0x60000000 EF_MIPS_ARCH_32R2 = 0x70000000 EF_MIPS_ARCH_64R2 = 0x80000000 For printing bit-sets we use the `yaml::IO::bitSetCase()`. It does not support bit-set/enumeration combinations and prints too many flags from an enumeration part. This patch fixes this problem. New method `yaml::IO::maskedBitSetCase()` handle "enumeration" part of bitset defined by provided mask. Patch reviewed by Nick Kledzik and Sean Silva. llvm-svn: 209504
2014-05-23 10:07:09 +02:00
#undef BCaseMask
[yaml2obj] Add support for ELF e_flags. Summary: The FileHeader mapping now accepts an optional Flags sequence that accepts the EF_<arch>_<flag> constants. When not given, Flags defaults to zero. Reviewers: atanasyan Reviewed By: atanasyan CC: llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D3213 llvm-svn: 205173
2014-03-31 11:44:05 +02:00
}
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
IO &IO, ELFYAML::ELF_SHT &Value) {
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-12 20:25:08 +02:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(SHT_NULL)
ECase(SHT_PROGBITS)
[yaml2obj][ELF] Make symbol table top-level key. Although in reality the symbol table in ELF resides in a section, the standard requires that there be no more than one SHT_SYMTAB. To enforce this constraint, it is cleaner to group all the symbols under a top-level `Symbols` key on the object file. llvm-svn: 184627
2013-06-22 03:38:00 +02:00
// No SHT_SYMTAB. Use the top-level `Symbols` key instead.
// FIXME: Issue a diagnostic with this information.
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
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)
[ELFYAML] Add more SHT_xxx flags to the YAML section type mapping. llvm-svn: 207904
2014-05-03 13:39:44 +02:00
ECase(SHT_LOOS)
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)
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-12 20:25:08 +02:00
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)
[Mips] Support SHT_MIPS_ABIFLAGS section type flag in the llvm-readobj, obj2yaml and yaml2obj tools. llvm-svn: 212908
2014-07-13 17:28:54 +02:00
ECase(SHT_MIPS_ABIFLAGS)
Add forgotten `break` statement. llvm-svn: 212910
2014-07-13 18:18:56 +02:00
break;
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-12 20:25:08 +02:00
default:
// Nothing to do.
break;
}
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
#undef ECase
}
void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
BCase(SHF_WRITE)
BCase(SHF_ALLOC)
ELF: Add support for the exclude section bit for gas compat. llvm-svn: 190769
2013-09-15 21:53:20 +02:00
BCase(SHF_EXCLUDE)
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
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)
#undef BCase
}
[yaml2obj][ELF] Support st_info through `Binding` and `Type` YAML keys. llvm-svn: 184263
2013-06-19 02:11:59 +02:00
void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
IO &IO, ELFYAML::ELF_STT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(STT_NOTYPE)
ECase(STT_OBJECT)
ECase(STT_FUNC)
ECase(STT_SECTION)
ECase(STT_FILE)
ECase(STT_COMMON)
ECase(STT_TLS)
ECase(STT_GNU_IFUNC)
#undef ECase
}
[yaml2obj][obj2yaml] Support ELF symbol's visibility flags (default/hidden/protected). llvm-svn: 210316
2014-06-06 09:41:57 +02:00
void ScalarEnumerationTraits<ELFYAML::ELF_STV>::enumeration(
IO &IO, ELFYAML::ELF_STV &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(STV_DEFAULT)
ECase(STV_INTERNAL)
ECase(STV_HIDDEN)
ECase(STV_PROTECTED)
#undef ECase
}
[ELF][yaml2obj] Handle additional MIPS specific st_other field flags The ELF symbol `st_other` field might contain additional flags besides visibility ones. This patch implements support for some MIPS specific flags. llvm-svn: 221491
2014-11-06 23:46:24 +01:00
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
}
[ELFYAML] Support mips64 relocation record format in yaml2obj/obj2yaml MIPS64 ELF file has a very specific relocation record format. Each record might specify up to three relocation operations. So the `r_info` field in fact consists of three relocation type sub-fields and optional code of "special" symbols. http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf page 40 The patch implements support of the MIPS64 relocation record format in yaml2obj/obj2yaml tools by introducing new optional Relocation fields: Type2, Type3, and SpecSym. These fields are recognized only if the object/YAML file relates to the MIPS64 target. Differential Revision: http://reviews.llvm.org/D7136 llvm-svn: 227044
2015-01-25 14:29:25 +01:00
void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
IO &IO, ELFYAML::ELF_RSS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(RSS_UNDEF)
ECase(RSS_GP)
ECase(RSS_GP0)
ECase(RSS_LOC)
#undef ECase
}
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
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");
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
switch (Object->Header.Machine) {
case ELF::EM_X86_64:
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#include "llvm/Support/ELFRelocs/x86_64.def"
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
break;
case ELF::EM_MIPS:
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#include "llvm/Support/ELFRelocs/Mips.def"
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
break;
case ELF::EM_HEXAGON:
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#include "llvm/Support/ELFRelocs/Hexagon.def"
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
break;
[yaml2obj] Support ELF x86 relocations. llvm-svn: 208228
2014-05-07 19:06:38 +02:00
case ELF::EM_386:
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#include "llvm/Support/ELFRelocs/i386.def"
[yaml2obj] Support ELF x86 relocations. llvm-svn: 208228
2014-05-07 19:06:38 +02:00
break;
[yaml2obj] Support AArch64 relocations. Patch by Daniel Stewart <stewartd@codeaurora.org>! Phabricator Revision: http://reviews.llvm.org/D6192 llvm-svn: 221639
2014-11-11 00:02:03 +01:00
case ELF::EM_AARCH64:
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#include "llvm/Support/ELFRelocs/AArch64.def"
[yaml2obj] Support AArch64 relocations. Patch by Daniel Stewart <stewartd@codeaurora.org>! Phabricator Revision: http://reviews.llvm.org/D6192 llvm-svn: 221639
2014-11-11 00:02:03 +01:00
break;
Add ARM relocations to ELFYAML Tested with check-all with no regressions. llvm-svn: 223112
2014-12-02 10:49:09 +01:00
case ELF::EM_ARM:
#include "llvm/Support/ELFRelocs/ARM.def"
break;
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
default:
llvm_unreachable("Unsupported architecture");
}
Remove duplication of relocation names in lib/Object/ELFYAML.cpp We can now use the ELF relocation .def files to create the mapping of relocation numbers to names and avoid having to duplicate the list of relocations. Patch by Will Newton. llvm-svn: 222567
2014-11-21 21:16:09 +01:00
#undef ELF_RELOC
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
}
[obj2yaml/yaml2obj] Add SHT_MIPS_ABIFLAGS section support This change adds support for the SHT_MIPS_ABIFLAGS section reading/writing to the obj2yaml and yaml2obj tools. llvm-svn: 236738
2015-05-07 17:40:48 +02:00
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X);
ECase(REG_NONE)
ECase(REG_32)
ECase(REG_64)
ECase(REG_128)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X);
ECase(FP_ANY)
ECase(FP_DOUBLE)
ECase(FP_SINGLE)
ECase(FP_SOFT)
ECase(FP_OLD_64)
ECase(FP_XX)
ECase(FP_64)
ECase(FP_64A)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X);
ECase(EXT_NONE)
ECase(EXT_XLR)
ECase(EXT_OCTEON2)
ECase(EXT_OCTEONP)
ECase(EXT_LOONGSON_3A)
ECase(EXT_OCTEON)
ECase(EXT_5900)
ECase(EXT_4650)
ECase(EXT_4010)
ECase(EXT_4100)
ECase(EXT_3900)
ECase(EXT_10000)
ECase(EXT_SB1)
ECase(EXT_4111)
ECase(EXT_4120)
ECase(EXT_5400)
ECase(EXT_5500)
ECase(EXT_LOONGSON_2E)
ECase(EXT_LOONGSON_2F)
ECase(EXT_OCTEON3)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
IO &IO, ELFYAML::MIPS_ISA &Value) {
IO.enumCase(Value, "MIPS1", 1);
IO.enumCase(Value, "MIPS2", 2);
IO.enumCase(Value, "MIPS3", 3);
IO.enumCase(Value, "MIPS4", 4);
IO.enumCase(Value, "MIPS5", 5);
IO.enumCase(Value, "MIPS32", 32);
IO.enumCase(Value, "MIPS64", 64);
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X);
BCase(DSP)
BCase(DSPR2)
BCase(EVA)
BCase(MCU)
BCase(MDMX)
BCase(MIPS3D)
BCase(MT)
BCase(SMARTMIPS)
BCase(VIRT)
BCase(MSA)
BCase(MIPS16)
BCase(MICROMIPS)
BCase(XPA)
#undef BCase
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X);
BCase(ODDSPREG)
#undef BCase
}
80-cols This slipped in during a hasty renaming. llvm-svn: 183810
2013-06-12 02:01:22 +02:00
void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
ELFYAML::FileHeader &FileHdr) {
Fix dubious type name similar to member name. Should bring bots back to life. llvm-svn: 183715
2013-06-11 02:13:52 +02:00
IO.mapRequired("Class", FileHdr.Class);
IO.mapRequired("Data", FileHdr.Data);
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 02:55:28 +02:00
IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
Fix dubious type name similar to member name. Should bring bots back to life. llvm-svn: 183715
2013-06-11 02:13:52 +02:00
IO.mapRequired("Type", FileHdr.Type);
IO.mapRequired("Machine", FileHdr.Machine);
[yaml2obj] Add support for ELF e_flags. Summary: The FileHeader mapping now accepts an optional Flags sequence that accepts the EF_<arch>_<flag> constants. When not given, Flags defaults to zero. Reviewers: atanasyan Reviewed By: atanasyan CC: llvm-commits Differential Revision: http://llvm-reviews.chandlerc.com/D3213 llvm-svn: 205173
2014-03-31 11:44:05 +02:00
IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
Fix dubious type name similar to member name. Should bring bots back to life. llvm-svn: 183715
2013-06-11 02:13:52 +02:00
IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
}
[ELF][yaml2obj] Handle additional MIPS specific st_other field flags The ELF symbol `st_other` field might contain additional flags besides visibility ones. This patch implements support for some MIPS specific flags. llvm-svn: 221491
2014-11-06 23:46:24 +01:00
namespace {
struct NormalizedOther {
NormalizedOther(IO &)
: Visibility(ELFYAML::ELF_STV(0)), Other(ELFYAML::ELF_STO(0)) {}
NormalizedOther(IO &, uint8_t Original)
: Visibility(Original & 0x3), Other(Original & ~0x3) {}
uint8_t denormalize(IO &) { return Visibility | Other; }
ELFYAML::ELF_STV Visibility;
ELFYAML::ELF_STO Other;
};
Revert r240137 (Fixed/added namespace ending comments using clang-tidy. NFC) Apparently, the style needs to be agreed upon first. llvm-svn: 240390
2015-06-23 11:49:53 +02:00
}
[ELF][yaml2obj] Handle additional MIPS specific st_other field flags The ELF symbol `st_other` field might contain additional flags besides visibility ones. This patch implements support for some MIPS specific flags. llvm-svn: 221491
2014-11-06 23:46:24 +01:00
[yaml2obj][ELF] Rudimentary symbol table support. Currently, we only output the name. llvm-svn: 184255
2013-06-19 01:14:03 +02:00
void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
IO.mapOptional("Name", Symbol.Name, StringRef());
[yaml2obj][ELF] Support st_info through `Binding` and `Type` YAML keys. llvm-svn: 184263
2013-06-19 02:11:59 +02:00
IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
[yaml2obj][ELF] Allow symbols to reference sections. llvm-svn: 184468
2013-06-20 22:59:41 +02:00
IO.mapOptional("Section", Symbol.Section, StringRef());
[yaml2obj][ELF] Add support for st_value and st_size. After this patch, the ELF file produced by `yaml2obj-elf-symbol-basic.yaml`, when linked and executed on x86_64 (under SysV ABI, obviously; I tested on Linux), produces a working executable that goes into an infinite loop! llvm-svn: 184469
2013-06-20 22:59:47 +02:00
IO.mapOptional("Value", Symbol.Value, Hex64(0));
IO.mapOptional("Size", Symbol.Size, Hex64(0));
[ELF][yaml2obj] Handle additional MIPS specific st_other field flags The ELF symbol `st_other` field might contain additional flags besides visibility ones. This patch implements support for some MIPS specific flags. llvm-svn: 221491
2014-11-06 23:46:24 +01:00
MappingNormalization<NormalizedOther, uint8_t> Keys(IO, Symbol.Other);
IO.mapOptional("Visibility", Keys->Visibility, ELFYAML::ELF_STV(0));
IO.mapOptional("Other", Keys->Other, ELFYAML::ELF_STO(0));
[yaml2obj][ELF] Rudimentary symbol table support. Currently, we only output the name. llvm-svn: 184255
2013-06-19 01:14:03 +02:00
}
[yaml2obj][ELF] Don't explicitly set `Binding` with STB_* Instead, just have 3 sub-lists, one for each of {STB_LOCAL,STB_GLOBAL,STB_WEAK}. This allows us to be a lot more explicit w.r.t. the symbol ordering in the object file, because if we allowed explicitly setting the STB_* `Binding` key for the symbol, then we might have ended up having to shuffle STB_LOCAL symbols to the front of the list, which is likely to cause confusion and potential for error. Also, this new approach is simpler ;) llvm-svn: 184506
2013-06-21 02:27:50 +02:00
void MappingTraits<ELFYAML::LocalGlobalWeakSymbols>::mapping(
IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols) {
IO.mapOptional("Local", Symbols.Local);
IO.mapOptional("Global", Symbols.Global);
IO.mapOptional("Weak", Symbols.Weak);
}
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
IO.mapOptional("Name", Section.Name, StringRef());
IO.mapRequired("Type", Section.Type);
IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
[yaml2obj] Add sh_addr via `Address` key. llvm-svn: 183954
2013-06-14 00:19:54 +02:00
IO.mapOptional("Address", Section.Address, Hex64(0));
[obj2yaml][ELF] Do not print empty Link and Info fields for ELF sections. llvm-svn: 208905
2014-05-15 20:04:02 +02:00
IO.mapOptional("Link", Section.Link, StringRef());
[yaml2obj] Add support for sh_addralign via `AddressAlign` key. For consistency, change the address in the test case from 0xDEADBEEF to 0xCAFEBABE since 0xCAFEBABE that actually has a 2-byte alignment. llvm-svn: 183962
2013-06-14 02:38:02 +02:00
IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
[obj2yaml/yaml2obj] Add SHT_GROUP support. This adds section group support to the tools obj2yaml and yaml2obj. llvm-svn: 230124
2015-02-21 05:28:26 +01:00
IO.mapOptional("Info", Section.Info, StringRef());
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
}
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Content", Section.Content);
[yaml2obj][ELF] Add an optional `Size` field to the YAML section declaration. Now the only method to configure ELF section's content and size is to assign a hexadecimal string to the `Content` field. Unfortunately this way is completely useless when you need to declare a really large section. To solve this problem this patch adds one more optional field `Size` to the `RawContentSection` structure. When yaml2obj generates an ELF file it uses the following algorithm: 1. If both `Content` and `Size` fields are missed create an empty section. 2. If only `Content` field is missed take section length from the `Size` field and fill the section by zero. 3. If only `Size` field is missed create a section using data from the `Content` field. 4. If both `Content` and `Size` fields are provided validate that the `Size` value is not less than size of `Content` data. Than take section length from the `Size`, fill beginning of the section by `Content` and the rest by zero. Examples -------- * Create a section 0x10000 bytes long filled by zero Name: .data Type: SHT_PROGBITS Flags: [ SHF_ALLOC ] Size: 0x10000 * Create a section 0x10000 bytes long starting from 'CA' 'FE' 'BA' 'BE' Name: .data Type: SHT_PROGBITS Flags: [ SHF_ALLOC ] Content: CAFEBABE Size: 0x10000 The patch reviewed by Michael Spencer. llvm-svn: 208995
2014-05-16 18:01:00 +02:00
IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
}
[ELFYAML] Fix handling SHT_NOBITS sections by obj2yaml/yaml2obj tools SHT_NOBITS sections do not have content in an object file. Now the yaml2obj tool does not accept `Content` field for such sections, and the obj2yaml tool does not attempt to read the section content from a file. Restore r241350 and r241352. llvm-svn: 241377
2015-07-04 01:00:54 +02:00
static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Size", Section.Size, Hex64(0));
}
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Relocations", Section.Relocations);
}
[obj2yaml/yaml2obj] Add SHT_GROUP support. This adds section group support to the tools obj2yaml and yaml2obj. llvm-svn: 230124
2015-02-21 05:28:26 +01:00
static void groupSectionMapping(IO &IO, ELFYAML::Group &group) {
commonSectionMapping(IO, group);
IO.mapRequired("Members", group.Members);
}
void MappingTraits<ELFYAML::SectionOrType>::mapping(
IO &IO, ELFYAML::SectionOrType &sectionOrType) {
IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
}
[obj2yaml/yaml2obj] Add SHT_MIPS_ABIFLAGS section support This change adds support for the SHT_MIPS_ABIFLAGS section reading/writing to the obj2yaml and yaml2obj tools. llvm-svn: 236738
2015-05-07 17:40:48 +02:00
static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Version", Section.Version, Hex16(0));
IO.mapRequired("ISA", Section.ISALevel);
IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
IO.mapOptional("ISAExtension", Section.ISAExtension,
ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
IO.mapOptional("FpABI", Section.FpABI,
ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
IO.mapOptional("GPRSize", Section.GPRSize,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR1Size", Section.CPR1Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR2Size", Section.CPR2Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
}
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
ELFYAML::ELF_SHT sectionType;
if (IO.outputting())
sectionType = Section->Type;
[obj2yaml] Support ELF input format in the obj2yaml tool. The ELF header e_flags field in the MIPS related test cases handled incorrectly. The obj2yaml prints too many flags. I will fix that in the next patches. The patch reviewed by Michael Spencer and Sean Silva. llvm-svn: 208752
2014-05-14 07:07:47 +02:00
else
IO.mapRequired("Type", sectionType);
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
switch (sectionType) {
case ELF::SHT_REL:
case ELF::SHT_RELA:
if (!IO.outputting())
Section.reset(new ELFYAML::RelocationSection());
sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
break;
[obj2yaml/yaml2obj] Add SHT_GROUP support. This adds section group support to the tools obj2yaml and yaml2obj. llvm-svn: 230124
2015-02-21 05:28:26 +01:00
case ELF::SHT_GROUP:
if (!IO.outputting())
Section.reset(new ELFYAML::Group());
groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
[ELFYAML] Fix handling SHT_NOBITS sections by obj2yaml/yaml2obj tools SHT_NOBITS sections do not have content in an object file. Now the yaml2obj tool does not accept `Content` field for such sections, and the obj2yaml tool does not attempt to read the section content from a file. Restore r241350 and r241352. llvm-svn: 241377
2015-07-04 01:00:54 +02:00
break;
case ELF::SHT_NOBITS:
if (!IO.outputting())
Section.reset(new ELFYAML::NoBitsSection());
sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
[obj2yaml/yaml2obj] Add SHT_GROUP support. This adds section group support to the tools obj2yaml and yaml2obj. llvm-svn: 230124
2015-02-21 05:28:26 +01:00
break;
[obj2yaml/yaml2obj] Add SHT_MIPS_ABIFLAGS section support This change adds support for the SHT_MIPS_ABIFLAGS section reading/writing to the obj2yaml and yaml2obj tools. llvm-svn: 236738
2015-05-07 17:40:48 +02:00
case ELF::SHT_MIPS_ABIFLAGS:
if (!IO.outputting())
Section.reset(new ELFYAML::MipsABIFlags());
sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
break;
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
default:
if (!IO.outputting())
Section.reset(new ELFYAML::RawContentSection());
sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
}
}
[yaml2obj][ELF] Add an optional `Size` field to the YAML section declaration. Now the only method to configure ELF section's content and size is to assign a hexadecimal string to the `Content` field. Unfortunately this way is completely useless when you need to declare a really large section. To solve this problem this patch adds one more optional field `Size` to the `RawContentSection` structure. When yaml2obj generates an ELF file it uses the following algorithm: 1. If both `Content` and `Size` fields are missed create an empty section. 2. If only `Content` field is missed take section length from the `Size` field and fill the section by zero. 3. If only `Size` field is missed create a section using data from the `Content` field. 4. If both `Content` and `Size` fields are provided validate that the `Size` value is not less than size of `Content` data. Than take section length from the `Size`, fill beginning of the section by `Content` and the rest by zero. Examples -------- * Create a section 0x10000 bytes long filled by zero Name: .data Type: SHT_PROGBITS Flags: [ SHF_ALLOC ] Size: 0x10000 * Create a section 0x10000 bytes long starting from 'CA' 'FE' 'BA' 'BE' Name: .data Type: SHT_PROGBITS Flags: [ SHF_ALLOC ] Content: CAFEBABE Size: 0x10000 The patch reviewed by Michael Spencer. llvm-svn: 208995
2014-05-16 18:01:00 +02:00
StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())
return StringRef();
return "Section size must be greater or equal to the content size";
}
[ELFYAML] Support mips64 relocation record format in yaml2obj/obj2yaml MIPS64 ELF file has a very specific relocation record format. Each record might specify up to three relocation operations. So the `r_info` field in fact consists of three relocation type sub-fields and optional code of "special" symbols. http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf page 40 The patch implements support of the MIPS64 relocation record format in yaml2obj/obj2yaml tools by introducing new optional Relocation fields: Type2, Type3, and SpecSym. These fields are recognized only if the object/YAML file relates to the MIPS64 target. Differential Revision: http://reviews.llvm.org/D7136 llvm-svn: 227044
2015-01-25 14:29:25 +01:00
namespace {
struct NormalizedMips64RelType {
NormalizedMips64RelType(IO &)
: Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
: Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
ELFYAML::ELF_REL denormalize(IO &) {
ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
return Res;
}
ELFYAML::ELF_REL Type;
ELFYAML::ELF_REL Type2;
ELFYAML::ELF_REL Type3;
ELFYAML::ELF_RSS SpecSym;
};
Revert r240137 (Fixed/added namespace ending comments using clang-tidy. NFC) Apparently, the style needs to be agreed upon first. llvm-svn: 240390
2015-06-23 11:49:53 +02:00
}
[ELFYAML] Support mips64 relocation record format in yaml2obj/obj2yaml MIPS64 ELF file has a very specific relocation record format. Each record might specify up to three relocation operations. So the `r_info` field in fact consists of three relocation type sub-fields and optional code of "special" symbols. http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf page 40 The patch implements support of the MIPS64 relocation record format in yaml2obj/obj2yaml tools by introducing new optional Relocation fields: Type2, Type3, and SpecSym. These fields are recognized only if the object/YAML file relates to the MIPS64 target. Differential Revision: http://reviews.llvm.org/D7136 llvm-svn: 227044
2015-01-25 14:29:25 +01:00
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
ELFYAML::Relocation &Rel) {
[ELFYAML] Support mips64 relocation record format in yaml2obj/obj2yaml MIPS64 ELF file has a very specific relocation record format. Each record might specify up to three relocation operations. So the `r_info` field in fact consists of three relocation type sub-fields and optional code of "special" symbols. http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf page 40 The patch implements support of the MIPS64 relocation record format in yaml2obj/obj2yaml tools by introducing new optional Relocation fields: Type2, Type3, and SpecSym. These fields are recognized only if the object/YAML file relates to the MIPS64 target. Differential Revision: http://reviews.llvm.org/D7136 llvm-svn: 227044
2015-01-25 14:29:25 +01:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
IO.mapRequired("Offset", Rel.Offset);
IO.mapRequired("Symbol", Rel.Symbol);
[ELFYAML] Support mips64 relocation record format in yaml2obj/obj2yaml MIPS64 ELF file has a very specific relocation record format. Each record might specify up to three relocation operations. So the `r_info` field in fact consists of three relocation type sub-fields and optional code of "special" symbols. http://techpubs.sgi.com/library/manuals/4000/007-4658-001/pdf/007-4658-001.pdf page 40 The patch implements support of the MIPS64 relocation record format in yaml2obj/obj2yaml tools by introducing new optional Relocation fields: Type2, Type3, and SpecSym. These fields are recognized only if the object/YAML file relates to the MIPS64 target. Differential Revision: http://reviews.llvm.org/D7136 llvm-svn: 227044
2015-01-25 14:29:25 +01:00
if (Object->Header.Machine == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
IO, Rel.Type);
IO.mapRequired("Type", Key->Type);
IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
} else
IO.mapRequired("Type", Rel.Type);
[ELFYAML] Provide default value 0 for YAML relocation addendum field Follow up to r227318. llvm-svn: 227422
2015-01-29 07:56:24 +01:00
IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
}
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
assert(!IO.getContext() && "The IO context is initialized already");
IO.setContext(&Object);
Fix dubious type name similar to member name. Should bring bots back to life. llvm-svn: 183715
2013-06-11 02:13:52 +02:00
IO.mapRequired("FileHeader", Object.Header);
[yaml2obj] Initial ELF section support. The current functionality is extremely basic and a bit rough around the edges, but it will flesh out in future commits. llvm-svn: 183953
2013-06-14 00:19:48 +02:00
IO.mapOptional("Sections", Object.Sections);
[yaml2obj][ELF] Make symbol table top-level key. Although in reality the symbol table in ELF resides in a section, the standard requires that there be no more than one SHT_SYMTAB. To enforce this constraint, it is cleaner to group all the symbols under a top-level `Symbols` key on the object file. llvm-svn: 184627
2013-06-22 03:38:00 +02:00
IO.mapOptional("Symbols", Object.Symbols);
[yaml2obj][ELF] ELF Relocations Support. The patch implements support for both relocation record formats: Elf_Rel and Elf_Rela. It is possible to define relocation against symbol only. Relocations against sections will be implemented later. Now yaml2obj recognizes X86_64, MIPS and Hexagon relocation types. Example of relocation section specification: Sections: - Name: .text Type: SHT_PROGBITS Content: "0000000000000000" AddressAlign: 16 Flags: [SHF_ALLOC] - Name: .rel.text Type: SHT_REL Info: .text AddressAlign: 4 Relocations: - Offset: 0x1 Symbol: glob1 Type: R_MIPS_32 - Offset: 0x2 Symbol: glob2 Type: R_MIPS_CALL16 The patch reviewed by Michael Spencer, Sean Silva, Shankar Easwaran. llvm-svn: 206017
2014-04-11 06:13:39 +02:00
IO.setContext(nullptr);
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
}
[obj2yaml/yaml2obj] Add SHT_MIPS_ABIFLAGS section support This change adds support for the SHT_MIPS_ABIFLAGS section reading/writing to the obj2yaml and yaml2obj tools. llvm-svn: 236738
2015-05-07 17:40:48 +02:00
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
[yaml2obj] Initial ELF support. Currently, only emitting the ELF header is supported (no sections or segments). The ELFYAML code organization is broadly similar to the COFFYAML code. llvm-svn: 183711
2013-06-11 01:44:15 +02:00
} // end namespace yaml
} // end namespace llvm
Reference in New Issue Copy Permalink