maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp

979 lines
29 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 07:44:15 +08: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.
//
//===----------------------------------------------------------------------===//
Move ObjectYAML code to a new library. It is only ever used by obj2yaml and yaml2obj. No point in linking it everywhere. llvm-svn: 262368
2016-03-02 03:15:06 +08:00
#include "llvm/ObjectYAML/ELFYAML.h"
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/ELF.h"
raw_ostream: Forward declare OpenFlags and include FileSystem.h only where necessary. llvm-svn: 207593
2014-04-30 07:26:49 +08:00
#include "llvm/Support/Casting.h"
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
#include "llvm/Support/ErrorHandling.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 23:40:48 +08:00
#include "llvm/Support/MipsABIFlags.h"
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
#include "llvm/Support/YAMLTraits.h"
#include <cassert>
#include <cstdint>
[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 07:44:15 +08:00
namespace llvm {
[yaml2obj][ELF] Add a virtual destructor to the ELFYAML::Section class to prevent memory leaks. llvm-svn: 206969
2014-04-23 19:10:55 +08:00
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
ELFYAML::Section::~Section() = default;
[yaml2obj][ELF] Add a virtual destructor to the ELFYAML::Section class to prevent memory leaks. llvm-svn: 206969
2014-04-23 19:10:55 +08: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 07:44:15 +08:00
namespace yaml {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[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 07:44:15 +08:00
#undef ECase
[Object][ELF] Test unknown type. llvm-svn: 226943
2015-01-24 05:58:09 +08: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 07:44:15 +08:00
}
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_PT>::enumeration(
IO &IO, ELFYAML::ELF_PT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(PT_NULL);
ECase(PT_LOAD);
ECase(PT_DYNAMIC);
ECase(PT_INTERP);
ECase(PT_NOTE);
ECase(PT_SHLIB);
ECase(PT_PHDR);
ECase(PT_TLS);
#undef ECase
IO.enumFallback<Hex32>(Value);
}
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08: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);
ECase(EM_IAMCU);
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);
ECase(EM_AMDGPU);
ECase(EM_RISCV);
ECase(EM_LANAI);
ECase(EM_BPF);
[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 07:44:15 +08:00
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
[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 07:44:15 +08:00
// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
// here.
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(ELFCLASS32);
ECase(ELFCLASS64);
[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 07:44:15 +08:00
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
IO &IO, ELFYAML::ELF_ELFDATA &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
[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 07:44:15 +08:00
// Since the semantics of ELFDATANONE is "invalid", just don't accept it
// here.
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(ELFDATA2LSB);
ECase(ELFDATA2MSB);
[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 07:44:15 +08:00
#undef ECase
}
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 08:55:28 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(ELFOSABI_NONE);
ECase(ELFOSABI_HPUX);
ECase(ELFOSABI_NETBSD);
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);
ECase(ELFOSABI_CLOUDABI);
ECase(ELFOSABI_AMDGPU_HSA);
AMDGPU: Add ELFOSABI_AMDGPU_PAL llvm-svn: 314843
2017-10-04 04:54:07 +08:00
ECase(ELFOSABI_AMDGPU_PAL);
AMDGPU: Add ELFOSABI_AMDGPU_MESA3D Differential Revision: https://reviews.llvm.org/D38387 llvm-svn: 314846
2017-10-04 05:14:14 +08:00
ECase(ELFOSABI_AMDGPU_MESA3D);
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(ELFOSABI_ARM);
AMDGPU: Add ELFOSABI_AMDGPU_PAL llvm-svn: 314843
2017-10-04 04:54:07 +08:00
ECase(ELFOSABI_C6000_ELFABI);
ECase(ELFOSABI_C6000_LINUX);
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(ELFOSABI_STANDALONE);
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 08:55:28 +08:00
#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 17:44:05 +08: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 19:39:50 +08:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
#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 19:39:50 +08:00
switch (Object->Header.Machine) {
case ELF::EM_ARM:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[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 19:39:50 +08:00
break;
case ELF::EM_MIPS:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[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 19:39:50 +08:00
break;
case ELF::EM_HEXAGON:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[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 19:39:50 +08:00
break;
[AVR] Add ELF constants to headers Also adds a 'trivial' ELF file. This was generated by assembling and linking a file with the symbol main which contains a single return instruction. llvm-svn: 251096
2015-10-23 14:05:55 +08:00
case ELF::EM_AVR:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[AVR] Add ELF constants to headers Also adds a 'trivial' ELF file. This was generated by assembling and linking a file with the symbol main which contains a single return instruction. llvm-svn: 251096
2015-10-23 14:05:55 +08:00
break;
[RISCV] Parse RISC-V eflags in ObjectYAML Differential Revision: https://reviews.llvm.org/D38311 Patch by Chih-Mao Chen. llvm-svn: 314770
2017-10-03 16:00:47 +08:00
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;
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
case ELF::EM_AMDGPU:
AMDGPU: Bring elf flags in sync with the spec - Add MACH flags - Add XNACK flag - Add reserved flags - Minor cleanups in docs Differential Revision: https://reviews.llvm.org/D43356 llvm-svn: 325399
2018-02-17 06:33:59 +08:00
BCaseMask(EF_AMDGPU_MACH_NONE, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_R630, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RS880, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV670, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV710, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV730, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_RV770, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CEDAR, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CYPRESS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_JUNIPER, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_REDWOOD, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_SUMO, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_BARTS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAICOS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_CAYMAN, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_R600_TURKS, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX600, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX601, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX700, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX701, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX702, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX703, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX704, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX801, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX802, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX803, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX810, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX900, EF_AMDGPU_MACH);
BCaseMask(EF_AMDGPU_MACH_AMDGCN_GFX902, EF_AMDGPU_MACH);
BCase(EF_AMDGPU_XNACK);
AMDGPU: Add and set AMDGPU-specific e_flags Differential Revision: https://reviews.llvm.org/D38556 llvm-svn: 314987
2017-10-06 00:19:18 +08:00
break;
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
case ELF::EM_X86_64:
break;
[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 19:39:50 +08:00
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 17:44:05 +08: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 16:07:09 +08: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 17:44:05 +08: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 06:19:48 +08: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-13 02:25:08 +08:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHT_NULL);
ECase(SHT_PROGBITS);
Reapply: Allow yaml2obj to order implicit sections for ELF Summary: This change allows yaml input to control the order of implicitly added sections (`.symtab`, `.strtab`, `.shstrtab`). The order is controlled by adding a placeholder section of the given name to the Sections field. This change is to support changes in D39582, where it is desirable to control the location of the `.dynsym` section. This reapplied version fixes: 1. use of a function call within an assert 2. failing lld test which has an unnamed section 3. incorrect section count when given an unnamed section Additionally, one more test to cover the unnamed section failure. Reviewers: compnerd, jakehehrlich Reviewed By: jakehehrlich Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D39749 llvm-svn: 317789
2017-11-09 22:53:43 +08:00
ECase(SHT_SYMTAB);
[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 09:38:00 +08:00
// FIXME: Issue a diagnostic with this information.
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08: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);
ECase(SHT_LOOS);
llvm-readobj: Add support for reading relocations in the Android packed format. This is in preparation for testing lld's upcoming relocation packing feature (D39152). I have verified that this implementation correctly unpacks the relocations from a Chromium DSO built with gold and the Android relocation packer for ARM32 and ARM64. Differential Revision: https://reviews.llvm.org/D39272 llvm-svn: 316543
2017-10-25 11:37:12 +08:00
ECase(SHT_ANDROID_REL);
ECase(SHT_ANDROID_RELA);
MC, Object: Reserve a section type, SHT_LLVM_ODRTAB, for the ODR table. This is part of the ODR checker proposal: http://lists.llvm.org/pipermail/llvm-dev/2017-June/113820.html Per discussion on the gnu-gabi mailing list [1] the section type range 0x6fff4c00..0x6fff4cff is reserved for LLVM. [1] https://sourceware.org/ml/gnu-gabi/2017-q2/msg00030.html Differential Revision: https://reviews.llvm.org/D33978 llvm-svn: 305407
2017-06-15 02:52:12 +08:00
ECase(SHT_LLVM_ODRTAB);
CodeGen: support an extension to pass linker options on ELF Introduce an extension to support passing linker options to the linker. These would be ignored by older linkers, but newer linkers which support this feature would be able to process the linker. Emit a special discarded section `.linker-option`. The content of this section is a pair of strings (key, value). The key is a type identifier for the parameter. This allows for an argument free parameter that will be processed by the linker with the value being the parameter. As an example, `lib` identifies a library to be linked against, traditionally the `-l` argument for Unix-based linkers with the parameter being the library name. Thanks to James Henderson, Cary Coutant, Rafael Espinolda, Sean Silva for the valuable discussion on the design of this feature. llvm-svn: 323783
2018-01-31 00:29:29 +08:00
ECase(SHT_LLVM_LINKER_OPTIONS);
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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-13 02:25:08 +08:00
switch (Object->Header.Machine) {
case ELF::EM_ARM:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(SHT_ARM_EXIDX);
ECase(SHT_ARM_PREEMPTMAP);
ECase(SHT_ARM_ATTRIBUTES);
ECase(SHT_ARM_DEBUGOVERLAY);
ECase(SHT_ARM_OVERLAYSECTION);
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-13 02:25:08 +08:00
break;
case ELF::EM_HEXAGON:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(SHT_HEX_ORDERED);
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-13 02:25:08 +08:00
break;
case ELF::EM_X86_64:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(SHT_X86_64_UNWIND);
[ELFYAML] Group ELF section type flags to target specific blocks. Recognize only flags which correspond to the current target. llvm-svn: 212880
2014-07-13 02:25:08 +08:00
break;
case ELF::EM_MIPS:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
ECase(SHT_MIPS_REGINFO);
ECase(SHT_MIPS_OPTIONS);
ECase(SHT_MIPS_ABIFLAGS);
Add forgotten `break` statement. llvm-svn: 212910
2014-07-14 00:18:56 +08: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-13 02:25:08 +08: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 06:19:48 +08:00
#undef ECase
}
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08:00
void ScalarBitSetTraits<ELFYAML::ELF_PF>::bitset(IO &IO,
ELFYAML::ELF_PF &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
BCase(PF_X);
BCase(PF_W);
BCase(PF_R);
}
[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 06:19:48 +08:00
void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
ELFYAML: Add support for parsing AMDGPU section attribute flags Reviewers: silvas Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D14444 llvm-svn: 253052
2015-11-14 01:06:29 +08:00
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#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);
[ObjectYAML] Handle SHF_COMPRESSED This was previously being silently dropped by obj2yaml and caused parsing errors with yaml2obj. Differential Revision: https://reviews.llvm.org/D38490 llvm-svn: 314768
2017-10-03 14:35:55 +08:00
BCase(SHF_COMPRESSED);
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
switch (Object->Header.Machine) {
[ARM] Implement execute-only support in CodeGen This implements execute-only support for ARM code generation, which prevents the compiler from generating data accesses to code sections. The following changes are involved: * Add the CodeGen option "-arm-execute-only" to the ARM code generator. * Add the clang flag "-mexecute-only" as well as the GCC-compatible alias "-mpure-code" to enable this option. * When enabled, literal pools are replaced with MOVW/MOVT instructions, with VMOV used in addition for floating-point literals. As the MOVT instruction is required, execute-only support is only available in Thumb mode for targets supporting ARMv8-M baseline or Thumb2. * Jump tables are placed in data sections when in execute-only mode. * The execute-only text section is assigned section ID 0, and is marked as unreadable with the SHF_ARM_PURECODE flag with symbol 'y'. This also overrides selection of ELF sections for globals. llvm-svn: 289784
2016-12-15 15:59:08 +08:00
case ELF::EM_ARM:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
BCase(SHF_ARM_PURECODE);
[ARM] Implement execute-only support in CodeGen This implements execute-only support for ARM code generation, which prevents the compiler from generating data accesses to code sections. The following changes are involved: * Add the CodeGen option "-arm-execute-only" to the ARM code generator. * Add the clang flag "-mexecute-only" as well as the GCC-compatible alias "-mpure-code" to enable this option. * When enabled, literal pools are replaced with MOVW/MOVT instructions, with VMOV used in addition for floating-point literals. As the MOVT instruction is required, execute-only support is only available in Thumb mode for targets supporting ARMv8-M baseline or Thumb2. * Jump tables are placed in data sections when in execute-only mode. * The execute-only text section is assigned section ID 0, and is marked as unreadable with the SHF_ARM_PURECODE flag with symbol 'y'. This also overrides selection of ELF sections for globals. llvm-svn: 289784
2016-12-15 15:59:08 +08:00
break;
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
case ELF::EM_HEXAGON:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
BCase(SHF_HEX_GPREL);
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
break;
case ELF::EM_MIPS:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
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);
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
break;
case ELF::EM_X86_64:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
BCase(SHF_X86_64_LARGE);
[llvm-readobj][ELF] Teach llvm-readobj to show arch specific ELF section's flags Some architecture specific ELF section flags might have the same value (for example SHF_X86_64_LARGE and SHF_HEX_GPREL) and we have to check machine architectures to select an appropriate set of possible flags. The patch selects architecture specific flags into separate arrays `ElfxxxSectionFlags` and combines `ElfSectionFlags` and `ElfxxxSectionFlags` before pass to the `StreamWriter::printFlags()` method. Differential Revision: http://reviews.llvm.org/D16269 llvm-svn: 258334
2016-01-21 03:15:18 +08:00
break;
ELFYAML: Add support for parsing AMDGPU section attribute flags Reviewers: silvas Subscribers: llvm-commits Differential Revision: http://reviews.llvm.org/D14444 llvm-svn: 253052
2015-11-14 01:06:29 +08: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 06:19:48 +08:00
#undef BCase
}
[yaml2obj][ELF] Add support for symbol indexes greater than SHN_LORESERVE Right now Symbols must be either undefined or defined in a specific section. Some symbols have section indexes like SHN_ABS however. This change adds support for outputting symbols that have such section indexes. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D37391 llvm-svn: 312745
2017-09-08 04:44:16 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_SHN>::enumeration(
IO &IO, ELFYAML::ELF_SHN &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(SHN_UNDEF);
ECase(SHN_LORESERVE);
ECase(SHN_LOPROC);
ECase(SHN_HIPROC);
ECase(SHN_LOOS);
ECase(SHN_HIOS);
ECase(SHN_ABS);
ECase(SHN_COMMON);
ECase(SHN_XINDEX);
ECase(SHN_HIRESERVE);
ECase(SHN_HEXAGON_SCOMMON);
ECase(SHN_HEXAGON_SCOMMON_1);
ECase(SHN_HEXAGON_SCOMMON_2);
ECase(SHN_HEXAGON_SCOMMON_4);
ECase(SHN_HEXAGON_SCOMMON_8);
#undef ECase
IO.enumFallback<Hex32>(Value);
}
[yaml2obj][ELF] Support st_info through `Binding` and `Type` YAML keys. llvm-svn: 184263
2013-06-19 08:11:59 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
IO &IO, ELFYAML::ELF_STT &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#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);
[yaml2obj][ELF] Support st_info through `Binding` and `Type` YAML keys. llvm-svn: 184263
2013-06-19 08:11:59 +08:00
#undef ECase
}
[yaml2obj][obj2yaml] Support ELF symbol's visibility flags (default/hidden/protected). llvm-svn: 210316
2014-06-06 15:41:57 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_STV>::enumeration(
IO &IO, ELFYAML::ELF_STV &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(STV_DEFAULT);
ECase(STV_INTERNAL);
ECase(STV_HIDDEN);
ECase(STV_PROTECTED);
[yaml2obj][obj2yaml] Support ELF symbol's visibility flags (default/hidden/protected). llvm-svn: 210316
2014-06-06 15:41:57 +08:00
#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-07 06:46:24 +08: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");
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X)
[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-07 06:46:24 +08:00
switch (Object->Header.Machine) {
case ELF::EM_MIPS:
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
BCase(STO_MIPS_OPTIONAL);
BCase(STO_MIPS_PLT);
BCase(STO_MIPS_PIC);
BCase(STO_MIPS_MICROMIPS);
[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-07 06:46:24 +08:00
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 21:29:25 +08:00
void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
IO &IO, ELFYAML::ELF_RSS &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, ELF::X)
ECase(RSS_UNDEF);
ECase(RSS_GP);
ECase(RSS_GP0);
ECase(RSS_LOC);
[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 21:29:25 +08:00
#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 12:13:39 +08: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-22 04:16:09 +08: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 12:13:39 +08:00
switch (Object->Header.Machine) {
case ELF::EM_X86_64:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/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 12:13:39 +08:00
break;
case ELF::EM_MIPS:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/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 12:13:39 +08:00
break;
case ELF::EM_HEXAGON:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/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 12:13:39 +08:00
break;
[yaml2obj] Support ELF x86 relocations. llvm-svn: 208228
2014-05-08 01:06:38 +08:00
case ELF::EM_386:
[ELF] elfiamcu triple should imply e_machine == EM_IAMCU Differential Revision: http://reviews.llvm.org/D14109 llvm-svn: 252043
2015-11-04 19:21:50 +08:00
case ELF::EM_IAMCU:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/i386.def"
[yaml2obj] Support ELF x86 relocations. llvm-svn: 208228
2014-05-08 01:06:38 +08: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 07:02:03 +08:00
case ELF::EM_AARCH64:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/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 07:02:03 +08:00
break;
Add ARM relocations to ELFYAML Tested with check-all with no regressions. llvm-svn: 223112
2014-12-02 17:49:09 +08:00
case ELF::EM_ARM:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/ARM.def"
Add ARM relocations to ELFYAML Tested with check-all with no regressions. llvm-svn: 223112
2014-12-02 17:49:09 +08:00
break;
[ARC] Prepare the implementation of relocation for LLD Reviewers: ruiu, kparzysz, petecoup, rafael Reviewed By: kparzysz Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D37556 llvm-svn: 313109
2017-09-13 09:49:49 +08:00
case ELF::EM_ARC:
#include "llvm/BinaryFormat/ELFRelocs/ARC.def"
break;
[RISCV] Add RISC-V ELF defines Add the necessary definitions for RISC-V ELF files, including relocs. Also make necessary trivial change to ELFYaml, llvm-objdump, and llvm-readobj in order to work with RISC-V ELFs. Differential Revision: https://reviews.llvm.org/D23557 llvm-svn: 285708
2016-11-02 00:59:37 +08:00
case ELF::EM_RISCV:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/RISCV.def"
[RISCV] Add RISC-V ELF defines Add the necessary definitions for RISC-V ELF files, including relocs. Also make necessary trivial change to ELFYaml, llvm-objdump, and llvm-readobj in order to work with RISC-V ELFs. Differential Revision: https://reviews.llvm.org/D23557 llvm-svn: 285708
2016-11-02 00:59:37 +08:00
break;
[lanai] Add Lanai backend. Add the Lanai backend to lib/Target. General Lanai backend discussion on llvm-dev thread "[RFC] Lanai backend" (http://lists.llvm.org/pipermail/llvm-dev/2016-February/095118.html). Differential Revision: http://reviews.llvm.org/D17011 llvm-svn: 264578
2016-03-28 21:09:54 +08:00
case ELF::EM_LANAI:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/Lanai.def"
[lanai] Add Lanai backend. Add the Lanai backend to lib/Target. General Lanai backend discussion on llvm-dev thread "[RFC] Lanai backend" (http://lists.llvm.org/pipermail/llvm-dev/2016-February/095118.html). Differential Revision: http://reviews.llvm.org/D17011 llvm-svn: 264578
2016-03-28 21:09:54 +08:00
break;
Support/ELF: Add AMDGPU relocation definitions to match documentation Reviewers: arsenm, kzhuravl, rafael Subscribers: llvm-commits, kzhuravl Differential Revision: http://reviews.llvm.org/D21443 llvm-svn: 273066
2016-06-18 06:38:08 +08:00
case ELF::EM_AMDGPU:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/AMDGPU.def"
Support/ELF: Add AMDGPU relocation definitions to match documentation Reviewers: arsenm, kzhuravl, rafael Subscribers: llvm-commits, kzhuravl Differential Revision: http://reviews.llvm.org/D21443 llvm-svn: 273066
2016-06-18 06:38:08 +08:00
break;
BPF: Use official ELF e_machine value The same value for EM_BPF is being propagated to glibc, elfutils, and binutils. Signed-off-by: Richard Henderson <rth@twiddle.net> Signed-off-by: Alexei Starovoitov <ast@kernel.org> llvm-svn: 275633
2016-07-16 06:27:55 +08:00
case ELF::EM_BPF:
Move Object format code to lib/BinaryFormat. This creates a new library called BinaryFormat that has all of the headers from llvm/Support containing structure and layout definitions for various types of binary formats like dwarf, coff, elf, etc as well as the code for identifying a file from its magic. Differential Revision: https://reviews.llvm.org/D33843 llvm-svn: 304864
2017-06-07 11:48:56 +08:00
#include "llvm/BinaryFormat/ELFRelocs/BPF.def"
BPF: Use official ELF e_machine value The same value for EM_BPF is being propagated to glibc, elfutils, and binutils. Signed-off-by: Richard Henderson <rth@twiddle.net> Signed-off-by: Alexei Starovoitov <ast@kernel.org> llvm-svn: 275633
2016-07-16 06:27:55 +08:00
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 12:13:39 +08: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-22 04:16:09 +08:00
#undef ELF_RELOC
[YAML] - Teach yaml2obj/obj2yaml to work with numeric relocation values. That may be useful if we want to produce or parse object containing broken relocation values using yaml2obj/obj2yaml. Previously that was impossible because only enum values were parsed correctly, this patch allows to put any numeric value as a relocation type. Differential revision: https://reviews.llvm.org/D34758 llvm-svn: 306814
2017-06-30 18:31:03 +08:00
IO.enumFallback<Hex32>(Value);
[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 12:13:39 +08: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 23:40:48 +08:00
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X)
ECase(REG_NONE);
ECase(REG_32);
ECase(REG_64);
ECase(REG_128);
[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 23:40:48 +08:00
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#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);
[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 23:40:48 +08:00
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#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);
[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 23:40:48 +08:00
#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) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#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);
[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 23:40:48 +08:00
#undef BCase
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
Make this file clang-format friendly and clang-format it. llvm-svn: 293689
2017-02-01 05:11:12 +08:00
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X)
BCase(ODDSPREG);
[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 23:40:48 +08:00
#undef BCase
}
80-cols This slipped in during a hasty renaming. llvm-svn: 183810
2013-06-12 08:01:22 +08: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 08:13:52 +08:00
IO.mapRequired("Class", FileHdr.Class);
IO.mapRequired("Data", FileHdr.Data);
[yaml2obj][ELF] Support ELFOSABI_* enum. llvm-svn: 184268
2013-06-19 08:55:28 +08: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 08:13:52 +08: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 17:44:05 +08: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 08:13:52 +08: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 07:44:15 +08:00
}
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08:00
void MappingTraits<ELFYAML::ProgramHeader>::mapping(
IO &IO, ELFYAML::ProgramHeader &Phdr) {
IO.mapRequired("Type", Phdr.Type);
IO.mapOptional("Flags", Phdr.Flags, ELFYAML::ELF_PF(0));
IO.mapOptional("Sections", Phdr.Sections);
IO.mapOptional("VAddr", Phdr.VAddr, Hex64(0));
IO.mapOptional("PAddr", Phdr.PAddr, Hex64(0));
[yaml2obj][ELF] Add support for setting alignment in program headers Sometimes program headers have larger alignments than any of the sections they contain. Currently yaml2obj can't produce such files. A bug recently appeared in llvm-objcopy that failed in such a case. I'd like to be able to add tests to llvm-objcopy for such cases. This change adds an optional alignment parameter to program headers that will be used instead of calculating the alignment. Differential Revision: https://reviews.llvm.org/D39130 llvm-svn: 317139
2017-11-02 07:14:48 +08:00
IO.mapOptional("Align", Phdr.Align);
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08: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-07 06:46:24 +08:00
namespace {
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08: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-07 06:46:24 +08:00
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;
};
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
} // end anonymous namespace
[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-07 06:46:24 +08:00
[yaml2obj][ELF] Rudimentary symbol table support. Currently, we only output the name. llvm-svn: 184255
2013-06-19 07:14:03 +08: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 08:11:59 +08:00
IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
[yaml2obj][ELF] Allow symbols to reference sections. llvm-svn: 184468
2013-06-21 04:59:41 +08:00
IO.mapOptional("Section", Symbol.Section, StringRef());
[yaml2obj][ELF] Add support for symbol indexes greater than SHN_LORESERVE Right now Symbols must be either undefined or defined in a specific section. Some symbols have section indexes like SHN_ABS however. This change adds support for outputting symbols that have such section indexes. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D37391 llvm-svn: 312745
2017-09-08 04:44:16 +08:00
IO.mapOptional("Index", Symbol.Index);
[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-21 04:59:47 +08: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-07 06:46:24 +08: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 07:14:03 +08:00
}
[yaml2obj][ELF] Add support for symbol indexes greater than SHN_LORESERVE Right now Symbols must be either undefined or defined in a specific section. Some symbols have section indexes like SHN_ABS however. This change adds support for outputting symbols that have such section indexes. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D37391 llvm-svn: 312745
2017-09-08 04:44:16 +08:00
StringRef MappingTraits<ELFYAML::Symbol>::validate(IO &IO,
ELFYAML::Symbol &Symbol) {
if (Symbol.Index && Symbol.Section.data()) {
return "Index and Section cannot both be specified for Symbol";
}
if (Symbol.Index && *Symbol.Index == ELFYAML::ELF_SHN(ELF::SHN_XINDEX)) {
return "Large indexes are not supported";
}
if (Symbol.Index && *Symbol.Index < ELFYAML::ELF_SHN(ELF::SHN_LORESERVE)) {
return "Use a section name to define which section a symbol is defined in";
}
return StringRef();
}
[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 08:27:50 +08: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 12:13:39 +08: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 06:19:48 +08: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 06:19:54 +08: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-16 02:04:02 +08: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 08:38:02 +08: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 12:28:26 +08: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 06:19:48 +08: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 12:13:39 +08: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-17 00:01:00 +08: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 12:13:39 +08: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 07:00:54 +08: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 12:13:39 +08: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 12:28:26 +08: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);
}
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08:00
void MappingTraits<ELFYAML::SectionName>::mapping(
IO &IO, ELFYAML::SectionName &sectionName) {
IO.mapRequired("Section", sectionName.Section);
}
[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 23:40:48 +08: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 12:13:39 +08: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 13:07:47 +08: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 12:13:39 +08: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 12:28:26 +08: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 07:00:54 +08: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 12:28:26 +08: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 23:40:48 +08: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 12:13:39 +08: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-17 00:01:00 +08: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 21:29:25 +08:00
namespace {
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08: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 21:29:25 +08:00
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;
};
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08:00
} // end anonymous namespace
[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 21:29:25 +08: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 12:13:39 +08: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 21:29:25 +08: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 12:13:39 +08:00
IO.mapRequired("Offset", Rel.Offset);
[yaml2obj][ELF] Make symbols optional for relocations Some kinds of relocations do not have symbols, like R_X86_64_RELATIVE for instance. I would like to test this case in D36554 but currently can't because symbols are required by yaml2obj. The other option is using the empty symbol but that doesn't seem quite right to me. This change makes the Symbol field of Relocation optional and in the case where the user does not specify a symbol name the Symbol index is 0. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D37276 llvm-svn: 312192
2017-08-31 07:13:31 +08:00
IO.mapOptional("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 21:29:25 +08: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 14:56:24 +08: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 12:13:39 +08: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 07:44:15 +08: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 12:13:39 +08:00
assert(!IO.getContext() && "The IO context is initialized already");
IO.setContext(&Object);
[yaml2obj] Remove --format option in favor of YAML tags Summary: Our YAML library's handling of tags isn't perfect, but it is good enough to get rid of the need for the --format argument to yaml2obj. This patch does exactly that. Instead of requiring --format, it infers the format based on the tags found in the object file. The supported tags are: !ELF !COFF !mach-o !fat-mach-o I have a corresponding patch that is quite large that fixes up all the in-tree test cases. Reviewers: rafael, Bigcheese, compnerd, silvas Subscribers: compnerd, llvm-commits Differential Revision: http://reviews.llvm.org/D21711 llvm-svn: 273915
2016-06-28 03:53:53 +08:00
IO.mapTag("!ELF", true);
Fix dubious type name similar to member name. Should bring bots back to life. llvm-svn: 183715
2013-06-11 08:13:52 +08:00
IO.mapRequired("FileHeader", Object.Header);
[yaml2obj][ELF] Add support for program headers This change adds basic support for program headers. I need to do some testing which requires generating program headers but I can't use ld.lld or clang to produce programs that have headers. I'd also like to test some strange things that those programs may never produce. Patch by Jake Ehrlich Differential Revision: https://reviews.llvm.org/D35276 llvm-svn: 308520
2017-07-20 04:38:46 +08:00
IO.mapOptional("ProgramHeaders", Object.ProgramHeaders);
[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 06:19:48 +08: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 09:38:00 +08:00
IO.mapOptional("Symbols", Object.Symbols);
Add ELF dynamic symbol support to yaml2obj/obj2yaml Summary: This change introduces a `DynamicSymbols` field to the ELF specific YAML supported by `yaml2obj` and `obj2yaml`. This grouping of symbols provides a way to represent ELF dynamic symbols. The `DynamicSymbols` structure is identical to the existing `Symbols`. Reviewers: compnerd, jakehehrlich, silvas Reviewed By: silvas Subscribers: silvas, jakehehrlich, llvm-commits Differential Revision: https://reviews.llvm.org/D39582 llvm-svn: 318433
2017-11-17 02:10:15 +08:00
IO.mapOptional("DynamicSymbols", Object.DynamicSymbols);
[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 12:13:39 +08: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 07:44:15 +08: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 23:40:48 +08: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 07:44:15 +08:00
} // end namespace yaml
[ObjectYAML] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC). llvm-svn: 306925
2017-07-01 09:35:55 +08: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 07:44:15 +08:00
} // end namespace llvm