6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-06-26 07:24:25 +00:00
Code Issues Projects Releases Wiki Activity

Simplify now that we always use an alignment of 2 for ELF files.

Browse Source 
This saves 123144 bytes out of llvm-nm on powerpc64le.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@238824 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Rafael Espindola
2015-06-02 12:05:27 +00:00
parent 6b35bec8ef
commit 9751e35f20
8 changed files with 116 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
include/llvm/Object/ELF.h
View File

@ -423,12 +423,10 @@ public:
StringRef getLoadName() const; StringRef getLoadName() const;
}; };
// Use an alignment of 2 for the typedefs since that is the worst case for typedef ELFFile<ELFType<support::little, false>> ELF32LEFile;
// ELF files in archives. typedef ELFFile<ELFType<support::little, true>> ELF64LEFile;
typedef ELFFile<ELFType<support::little, 2, false> > ELF32LEFile; typedef ELFFile<ELFType<support::big, false>> ELF32BEFile;
typedef ELFFile<ELFType<support::little, 2, true> > ELF64LEFile; typedef ELFFile<ELFType<support::big, true>> ELF64BEFile;
typedef ELFFile<ELFType<support::big, 2, false> > ELF32BEFile;
typedef ELFFile<ELFType<support::big, 2, true> > ELF64BEFile;
// Iterate through the version definitions, and place each Elf_Verdef // Iterate through the version definitions, and place each Elf_Verdef
// in the VersionMap according to its index. // in the VersionMap according to its index.

10
include/llvm/Object/ELFObjectFile.h
View File

@ -243,12 +243,10 @@ public:
bool isRelocatableObject() const override; bool isRelocatableObject() const override;
}; };
// Use an alignment of 2 for the typedefs since that is the worst case for typedef ELFObjectFile<ELFType<support::little, false>> ELF32LEObjectFile;
// ELF files in archives. typedef ELFObjectFile<ELFType<support::little, true>> ELF64LEObjectFile;
typedef ELFObjectFile<ELFType<support::little, 2, false> > ELF32LEObjectFile; typedef ELFObjectFile<ELFType<support::big, false>> ELF32BEObjectFile;
typedef ELFObjectFile<ELFType<support::little, 2, true> > ELF64LEObjectFile; typedef ELFObjectFile<ELFType<support::big, true>> ELF64BEObjectFile;
typedef ELFObjectFile<ELFType<support::big, 2, false> > ELF32BEObjectFile;
typedef ELFObjectFile<ELFType<support::big, 2, true> > ELF64BEObjectFile;
template <class ELFT> template <class ELFT>
void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Symb) const { void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Symb) const {

186
include/llvm/Object/ELFTypes.h
View File

@ -10,7 +10,6 @@
#ifndef LLVM_OBJECT_ELFTYPES_H #ifndef LLVM_OBJECT_ELFTYPES_H
#define LLVM_OBJECT_ELFTYPES_H #define LLVM_OBJECT_ELFTYPES_H
#include "llvm/Support/AlignOf.h"
#include "llvm/Support/DataTypes.h" #include "llvm/Support/DataTypes.h"
#include "llvm/Support/ELF.h" #include "llvm/Support/ELF.h"
#include "llvm/Support/Endian.h" #include "llvm/Support/Endian.h"
@ -20,95 +19,74 @@ namespace object {
using support::endianness; using support::endianness;
template <endianness target_endianness, std::size_t max_alignment, template <endianness target_endianness, bool is64Bits> struct ELFType {
bool is64Bits>
struct ELFType {
static const endianness TargetEndianness = target_endianness; static const endianness TargetEndianness = target_endianness;
static const std::size_t MaxAlignment = max_alignment;
static const bool Is64Bits = is64Bits; static const bool Is64Bits = is64Bits;
}; };
template <typename T, int max_align> struct MaximumAlignment { // Use an alignment of 2 for the typedefs since that is the worst case for
enum { value = AlignOf<T>::Alignment > max_align ? max_align // ELF files in archives.
: AlignOf<T>::Alignment
};
};
// Templates to choose Elf_Addr and Elf_Off depending on is64Bits. // Templates to choose Elf_Addr and Elf_Off depending on is64Bits.
template <endianness target_endianness, std::size_t max_alignment> template <endianness target_endianness> struct ELFDataTypeTypedefHelperCommon {
struct ELFDataTypeTypedefHelperCommon {
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
uint16_t, target_endianness, uint16_t, target_endianness, 2> Elf_Half;
MaximumAlignment<uint16_t, max_alignment>::value> Elf_Half;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
uint32_t, target_endianness, uint32_t, target_endianness, 2> Elf_Word;
MaximumAlignment<uint32_t, max_alignment>::value> Elf_Word;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
int32_t, target_endianness, int32_t, target_endianness, 2> Elf_Sword;
MaximumAlignment<int32_t, max_alignment>::value> Elf_Sword;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
uint64_t, target_endianness, uint64_t, target_endianness, 2> Elf_Xword;
MaximumAlignment<uint64_t, max_alignment>::value> Elf_Xword;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
int64_t, target_endianness, int64_t, target_endianness, 2> Elf_Sxword;
MaximumAlignment<int64_t, max_alignment>::value> Elf_Sxword;
}; };
template <class ELFT> struct ELFDataTypeTypedefHelper; template <class ELFT> struct ELFDataTypeTypedefHelper;
/// ELF 32bit types. /// ELF 32bit types.
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, MaxAlign, false> > struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, false>>
: ELFDataTypeTypedefHelperCommon<TargetEndianness, MaxAlign> { : ELFDataTypeTypedefHelperCommon<TargetEndianness> {
typedef uint32_t value_type; typedef uint32_t value_type;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
value_type, TargetEndianness, value_type, TargetEndianness, 2> Elf_Addr;
MaximumAlignment<value_type, MaxAlign>::value> Elf_Addr;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
value_type, TargetEndianness, value_type, TargetEndianness, 2> Elf_Off;
MaximumAlignment<value_type, MaxAlign>::value> Elf_Off;
}; };
/// ELF 64bit types. /// ELF 64bit types.
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, MaxAlign, true> > struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, true>>
: ELFDataTypeTypedefHelperCommon<TargetEndianness, MaxAlign> { : ELFDataTypeTypedefHelperCommon<TargetEndianness> {
typedef uint64_t value_type; typedef uint64_t value_type;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
value_type, TargetEndianness, value_type, TargetEndianness, 2> Elf_Addr;
MaximumAlignment<value_type, MaxAlign>::value> Elf_Addr;
typedef support::detail::packed_endian_specific_integral< typedef support::detail::packed_endian_specific_integral<
value_type, TargetEndianness, value_type, TargetEndianness, 2> Elf_Off;
MaximumAlignment<value_type, MaxAlign>::value> Elf_Off;
}; };
// I really don't like doing this, but the alternative is copypasta. // I really don't like doing this, but the alternative is copypasta.
#define LLVM_ELF_IMPORT_TYPES(E, M, W) \ #define LLVM_ELF_IMPORT_TYPES(E, W) \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Addr \ typedef typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Addr Elf_Addr; \
Elf_Addr; \ typedef typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Off Elf_Off; \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Off \ typedef typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Half Elf_Half; \
Elf_Off; \ typedef typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Word Elf_Word; \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Half \ typedef \
Elf_Half; \ typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Sword Elf_Sword; \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Word \ typedef \
Elf_Word; \ typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Xword Elf_Xword; \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Sword \ typedef \
Elf_Sword; \ typename ELFDataTypeTypedefHelper<ELFType<E, W>>::Elf_Sxword Elf_Sxword;
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Xword \
Elf_Xword; \
typedef typename ELFDataTypeTypedefHelper<ELFType<E, M, W> >::Elf_Sxword \
Elf_Sxword;
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \ #define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \
LLVM_ELF_IMPORT_TYPES(ELFT::TargetEndianness, ELFT::MaxAlignment, \ LLVM_ELF_IMPORT_TYPES(ELFT::TargetEndianness, ELFT::Is64Bits)
ELFT::Is64Bits)
// Section header. // Section header.
template <class ELFT> struct Elf_Shdr_Base; template <class ELFT> struct Elf_Shdr_Base;
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Shdr_Base<ELFType<TargetEndianness, MaxAlign, false> > { struct Elf_Shdr_Base<ELFType<TargetEndianness, false>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Word sh_name; // Section name (index into string table) Elf_Word sh_name; // Section name (index into string table)
Elf_Word sh_type; // Section type (SHT_*) Elf_Word sh_type; // Section type (SHT_*)
Elf_Word sh_flags; // Section flags (SHF_*) Elf_Word sh_flags; // Section flags (SHF_*)
@ -121,9 +99,9 @@ struct Elf_Shdr_Base<ELFType<TargetEndianness, MaxAlign, false> > {
Elf_Word sh_entsize; // Size of records contained within the section Elf_Word sh_entsize; // Size of records contained within the section
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Shdr_Base<ELFType<TargetEndianness, MaxAlign, true> > { struct Elf_Shdr_Base<ELFType<TargetEndianness, true>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Word sh_name; // Section name (index into string table) Elf_Word sh_name; // Section name (index into string table)
Elf_Word sh_type; // Section type (SHT_*) Elf_Word sh_type; // Section type (SHT_*)
Elf_Xword sh_flags; // Section flags (SHF_*) Elf_Xword sh_flags; // Section flags (SHF_*)
@ -151,9 +129,9 @@ struct Elf_Shdr_Impl : Elf_Shdr_Base<ELFT> {
template <class ELFT> struct Elf_Sym_Base; template <class ELFT> struct Elf_Sym_Base;
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Sym_Base<ELFType<TargetEndianness, MaxAlign, false> > { struct Elf_Sym_Base<ELFType<TargetEndianness, false>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Word st_name; // Symbol name (index into string table) Elf_Word st_name; // Symbol name (index into string table)
Elf_Addr st_value; // Value or address associated with the symbol Elf_Addr st_value; // Value or address associated with the symbol
Elf_Word st_size; // Size of the symbol Elf_Word st_size; // Size of the symbol
@ -162,9 +140,9 @@ struct Elf_Sym_Base<ELFType<TargetEndianness, MaxAlign, false> > {
Elf_Half st_shndx; // Which section (header table index) it's defined in Elf_Half st_shndx; // Which section (header table index) it's defined in
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Sym_Base<ELFType<TargetEndianness, MaxAlign, true> > { struct Elf_Sym_Base<ELFType<TargetEndianness, true>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Word st_name; // Symbol name (index into string table) Elf_Word st_name; // Symbol name (index into string table)
unsigned char st_info; // Symbol's type and binding attributes unsigned char st_info; // Symbol's type and binding attributes
unsigned char st_other; // Must be zero; reserved unsigned char st_other; // Must be zero; reserved
@ -267,9 +245,9 @@ struct Elf_Vernaux_Impl {
/// table section (.dynamic) look like. /// table section (.dynamic) look like.
template <class ELFT> struct Elf_Dyn_Base; template <class ELFT> struct Elf_Dyn_Base;
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Dyn_Base<ELFType<TargetEndianness, MaxAlign, false> > { struct Elf_Dyn_Base<ELFType<TargetEndianness, false>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Sword d_tag; Elf_Sword d_tag;
union { union {
Elf_Word d_val; Elf_Word d_val;
@ -277,9 +255,9 @@ struct Elf_Dyn_Base<ELFType<TargetEndianness, MaxAlign, false> > {
} d_un; } d_un;
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Dyn_Base<ELFType<TargetEndianness, MaxAlign, true> > { struct Elf_Dyn_Base<ELFType<TargetEndianness, true>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Sxword d_tag; Elf_Sxword d_tag;
union { union {
Elf_Xword d_val; Elf_Xword d_val;
@ -300,9 +278,9 @@ struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> {
// Elf_Rel: Elf Relocation // Elf_Rel: Elf Relocation
template <class ELFT, bool isRela> struct Elf_Rel_Base; template <class ELFT, bool isRela> struct Elf_Rel_Base;
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, false> { struct Elf_Rel_Base<ELFType<TargetEndianness, false>, false> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
Elf_Word r_info; // Symbol table index and type of relocation to apply Elf_Word r_info; // Symbol table index and type of relocation to apply
@ -316,9 +294,9 @@ struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, false> {
} }
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, false> { struct Elf_Rel_Base<ELFType<TargetEndianness, true>, false> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
Elf_Xword r_info; // Symbol table index and type of relocation to apply Elf_Xword r_info; // Symbol table index and type of relocation to apply
@ -341,9 +319,9 @@ struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, false> {
} }
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, true> { struct Elf_Rel_Base<ELFType<TargetEndianness, false>, true> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
Elf_Word r_info; // Symbol table index and type of relocation to apply Elf_Word r_info; // Symbol table index and type of relocation to apply
Elf_Sword r_addend; // Compute value for relocatable field by adding this Elf_Sword r_addend; // Compute value for relocatable field by adding this
@ -358,9 +336,9 @@ struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, false>, true> {
} }
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, true> { struct Elf_Rel_Base<ELFType<TargetEndianness, true>, true> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Addr r_offset; // Location (file byte offset, or program virtual addr) Elf_Addr r_offset; // Location (file byte offset, or program virtual addr)
Elf_Xword r_info; // Symbol table index and type of relocation to apply Elf_Xword r_info; // Symbol table index and type of relocation to apply
Elf_Sxword r_addend; // Compute value for relocatable field by adding this. Elf_Sxword r_addend; // Compute value for relocatable field by adding this.
@ -386,11 +364,10 @@ struct Elf_Rel_Base<ELFType<TargetEndianness, MaxAlign, true>, true> {
template <class ELFT, bool isRela> struct Elf_Rel_Impl; template <class ELFT, bool isRela> struct Elf_Rel_Impl;
template <endianness TargetEndianness, std::size_t MaxAlign, bool isRela> template <endianness TargetEndianness, bool isRela>
struct Elf_Rel_Impl<ELFType<TargetEndianness, MaxAlign, true>, struct Elf_Rel_Impl<ELFType<TargetEndianness, true>, isRela>
isRela> : Elf_Rel_Base< : Elf_Rel_Base<ELFType<TargetEndianness, true>, isRela> {
ELFType<TargetEndianness, MaxAlign, true>, isRela> { LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true)
// These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE, // These accessors and mutators correspond to the ELF64_R_SYM, ELF64_R_TYPE,
// and ELF64_R_INFO macros defined in the ELF specification: // and ELF64_R_INFO macros defined in the ELF specification:
@ -411,11 +388,10 @@ struct Elf_Rel_Impl<ELFType<TargetEndianness, MaxAlign, true>,
} }
}; };
template <endianness TargetEndianness, std::size_t MaxAlign, bool isRela> template <endianness TargetEndianness, bool isRela>
struct Elf_Rel_Impl<ELFType<TargetEndianness, MaxAlign, false>, struct Elf_Rel_Impl<ELFType<TargetEndianness, false>, isRela>
isRela> : Elf_Rel_Base< : Elf_Rel_Base<ELFType<TargetEndianness, false>, isRela> {
ELFType<TargetEndianness, MaxAlign, false>, isRela> { LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false)
// These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE, // These accessors and mutators correspond to the ELF32_R_SYM, ELF32_R_TYPE,
// and ELF32_R_INFO macros defined in the ELF specification: // and ELF32_R_INFO macros defined in the ELF specification:
@ -463,9 +439,9 @@ struct Elf_Ehdr_Impl {
template <class ELFT> struct Elf_Phdr_Impl; template <class ELFT> struct Elf_Phdr_Impl;
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, false> > { struct Elf_Phdr_Impl<ELFType<TargetEndianness, false>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Word p_type; // Type of segment Elf_Word p_type; // Type of segment
Elf_Off p_offset; // FileOffset where segment is located, in bytes Elf_Off p_offset; // FileOffset where segment is located, in bytes
Elf_Addr p_vaddr; // Virtual Address of beginning of segment Elf_Addr p_vaddr; // Virtual Address of beginning of segment
@ -476,9 +452,9 @@ struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, false> > {
Elf_Word p_align; // Segment alignment constraint Elf_Word p_align; // Segment alignment constraint
}; };
template <endianness TargetEndianness, std::size_t MaxAlign> template <endianness TargetEndianness>
struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, true> > { struct Elf_Phdr_Impl<ELFType<TargetEndianness, true>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Word p_type; // Type of segment Elf_Word p_type; // Type of segment
Elf_Word p_flags; // Segment flags Elf_Word p_flags; // Segment flags
Elf_Off p_offset; // FileOffset where segment is located, in bytes Elf_Off p_offset; // FileOffset where segment is located, in bytes
@ -493,17 +469,17 @@ struct Elf_Phdr_Impl<ELFType<TargetEndianness, MaxAlign, true> > {
template <class ELFT> template <class ELFT>
struct Elf_Mips_RegInfo; struct Elf_Mips_RegInfo;
template <llvm::support::endianness TargetEndianness, std::size_t MaxAlign> template <llvm::support::endianness TargetEndianness>
struct Elf_Mips_RegInfo<ELFType<TargetEndianness, MaxAlign, false>> { struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, false) LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
Elf_Word ri_gprmask; // bit-mask of used general registers Elf_Word ri_gprmask; // bit-mask of used general registers
Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers
Elf_Addr ri_gp_value; // gp register value Elf_Addr ri_gp_value; // gp register value
}; };
template <llvm::support::endianness TargetEndianness, std::size_t MaxAlign> template <llvm::support::endianness TargetEndianness>
struct Elf_Mips_RegInfo<ELFType<TargetEndianness, MaxAlign, true>> { struct Elf_Mips_RegInfo<ELFType<TargetEndianness, true>> {
LLVM_ELF_IMPORT_TYPES(TargetEndianness, MaxAlign, true) LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
Elf_Word ri_gprmask; // bit-mask of used general registers Elf_Word ri_gprmask; // bit-mask of used general registers
Elf_Word ri_pad; // unused padding field Elf_Word ri_pad; // unused padding field
Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers Elf_Word ri_cprmask[4]; // bit-mask of used co-processor registers

13
include/llvm/Support/Compiler.h
View File

@ -350,19 +350,6 @@
# define LLVM_ADDRESS_SANITIZER_BUILD 0 # define LLVM_ADDRESS_SANITIZER_BUILD 0
#endif #endif
/// \macro LLVM_IS_UNALIGNED_ACCESS_FAST
/// \brief Is unaligned memory access fast on the host machine.
///
/// Don't specialize on alignment for platforms where unaligned memory accesses
/// generates the same code as aligned memory accesses for common types.
#if defined(_M_AMD64) || defined(_M_IX86) || defined(__amd64) || \
defined(__amd64__) || defined(__x86_64) || defined(__x86_64__) || \
defined(_X86_) || defined(__i386) || defined(__i386__)
# define LLVM_IS_UNALIGNED_ACCESS_FAST 1
#else
# define LLVM_IS_UNALIGNED_ACCESS_FAST 0
#endif
/// \brief Mark debug helper function definitions like dump() that should not be /// \brief Mark debug helper function definitions like dump() that should not be
/// stripped from debug builds. /// stripped from debug builds.
// FIXME: Move this to a private config.h as it's not usable in public headers. // FIXME: Move this to a private config.h as it's not usable in public headers.

8
lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.cpp
View File

@ -157,16 +157,16 @@ OwningBinary<ObjectFile> createELFDebugObject(const ObjectFile &Obj,
std::unique_ptr<ObjectFile> DebugObj; std::unique_ptr<ObjectFile> DebugObj;
if (Obj.getBytesInAddress() == 4 && Obj.isLittleEndian()) { if (Obj.getBytesInAddress() == 4 && Obj.isLittleEndian()) {
typedef ELFType<support::little, 2, false> ELF32LE; typedef ELFType<support::little, false> ELF32LE;
DebugObj = createRTDyldELFObject<ELF32LE>(Buffer->getMemBufferRef(), L, ec); DebugObj = createRTDyldELFObject<ELF32LE>(Buffer->getMemBufferRef(), L, ec);
} else if (Obj.getBytesInAddress() == 4 && !Obj.isLittleEndian()) { } else if (Obj.getBytesInAddress() == 4 && !Obj.isLittleEndian()) {
typedef ELFType<support::big, 2, false> ELF32BE; typedef ELFType<support::big, false> ELF32BE;
DebugObj = createRTDyldELFObject<ELF32BE>(Buffer->getMemBufferRef(), L, ec); DebugObj = createRTDyldELFObject<ELF32BE>(Buffer->getMemBufferRef(), L, ec);
} else if (Obj.getBytesInAddress() == 8 && !Obj.isLittleEndian()) { } else if (Obj.getBytesInAddress() == 8 && !Obj.isLittleEndian()) {
typedef ELFType<support::big, 2, true> ELF64BE; typedef ELFType<support::big, true> ELF64BE;
DebugObj = createRTDyldELFObject<ELF64BE>(Buffer->getMemBufferRef(), L, ec); DebugObj = createRTDyldELFObject<ELF64BE>(Buffer->getMemBufferRef(), L, ec);
} else if (Obj.getBytesInAddress() == 8 && Obj.isLittleEndian()) { } else if (Obj.getBytesInAddress() == 8 && Obj.isLittleEndian()) {
typedef ELFType<support::little, 2, true> ELF64LE; typedef ELFType<support::little, true> ELF64LE;
DebugObj = createRTDyldELFObject<ELF64LE>(Buffer->getMemBufferRef(), L, ec); DebugObj = createRTDyldELFObject<ELF64LE>(Buffer->getMemBufferRef(), L, ec);
} else } else
llvm_unreachable("Unexpected ELF format"); llvm_unreachable("Unexpected ELF format");

58
lib/Object/ELFObjectFile.cpp
View File

@ -27,51 +27,27 @@ ObjectFile::createELFObjectFile(MemoryBufferRef Obj) {
std::size_t MaxAlignment = std::size_t MaxAlignment =
1ULL << countTrailingZeros(uintptr_t(Obj.getBufferStart())); 1ULL << countTrailingZeros(uintptr_t(Obj.getBufferStart()));
if (MaxAlignment < 2)
return object_error::parse_failed;
std::error_code EC; std::error_code EC;
std::unique_ptr<ObjectFile> R; std::unique_ptr<ObjectFile> R;
if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2LSB) if (Ident.first == ELF::ELFCLASS32) {
#if !LLVM_IS_UNALIGNED_ACCESS_FAST if (Ident.second == ELF::ELFDATA2LSB)
if (MaxAlignment >= 4) R.reset(new ELFObjectFile<ELFType<support::little, false>>(Obj, EC));
R.reset(new ELFObjectFile<ELFType<support::little, 4, false>>(Obj, EC)); else if (Ident.second == ELF::ELFDATA2MSB)
else R.reset(new ELFObjectFile<ELFType<support::big, false>>(Obj, EC));
#endif
if (MaxAlignment >= 2)
R.reset(new ELFObjectFile<ELFType<support::little, 2, false>>(Obj, EC));
else
return object_error::parse_failed;
else if (Ident.first == ELF::ELFCLASS32 && Ident.second == ELF::ELFDATA2MSB)
#if !LLVM_IS_UNALIGNED_ACCESS_FAST
if (MaxAlignment >= 4)
R.reset(new ELFObjectFile<ELFType<support::big, 4, false>>(Obj, EC));
else
#endif
if (MaxAlignment >= 2)
R.reset(new ELFObjectFile<ELFType<support::big, 2, false>>(Obj, EC));
else
return object_error::parse_failed;
else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2MSB)
#if !LLVM_IS_UNALIGNED_ACCESS_FAST
if (MaxAlignment >= 8)
R.reset(new ELFObjectFile<ELFType<support::big, 8, true>>(Obj, EC));
else
#endif
if (MaxAlignment >= 2)
R.reset(new ELFObjectFile<ELFType<support::big, 2, true>>(Obj, EC));
else
return object_error::parse_failed;
else if (Ident.first == ELF::ELFCLASS64 && Ident.second == ELF::ELFDATA2LSB) {
#if !LLVM_IS_UNALIGNED_ACCESS_FAST
if (MaxAlignment >= 8)
R.reset(new ELFObjectFile<ELFType<support::little, 8, true>>(Obj, EC));
else
#endif
if (MaxAlignment >= 2)
R.reset(new ELFObjectFile<ELFType<support::little, 2, true>>(Obj, EC));
else
return object_error::parse_failed;
}
else else
llvm_unreachable("Buffer is not an ELF object file!"); llvm_unreachable("Buffer is not an ELF object file!");
} else {
assert(Ident.first == ELF::ELFCLASS64);
if (Ident.second == ELF::ELFDATA2LSB)
R.reset(new ELFObjectFile<ELFType<support::little, true>>(Obj, EC));
else if (Ident.second == ELF::ELFDATA2MSB)
R.reset(new ELFObjectFile<ELFType<support::big, true>>(Obj, EC));
else
llvm_unreachable("Buffer is not an ELF object file!");
}
if (EC) if (EC)
return EC; return EC;

8
tools/llvm-readobj/ELFDumper.cpp
View File

@ -991,11 +991,10 @@ void ELFDumper<ELFT>::printUnwindInfo() {
} }
namespace { namespace {
template <> template <> void ELFDumper<ELFType<support::little, false>>::printUnwindInfo() {
void ELFDumper<ELFType<support::little, 2, false> >::printUnwindInfo() {
const unsigned Machine = Obj->getHeader()->e_machine; const unsigned Machine = Obj->getHeader()->e_machine;
if (Machine == EM_ARM) { if (Machine == EM_ARM) {
ARM::EHABI::PrinterContext<ELFType<support::little, 2, false> > Ctx(W, Obj); ARM::EHABI::PrinterContext<ELFType<support::little, false>> Ctx(W, Obj);
return Ctx.PrintUnwindInformation(); return Ctx.PrintUnwindInformation();
} }
W.startLine() << "UnwindInfo not implemented.\n"; W.startLine() << "UnwindInfo not implemented.\n";
@ -1075,8 +1074,7 @@ void ELFDumper<ELFT>::printAttributes() {
} }
namespace { namespace {
template <> template <> void ELFDumper<ELFType<support::little, false>>::printAttributes() {
void ELFDumper<ELFType<support::little, 2, false> >::printAttributes() {
if (Obj->getHeader()->e_machine != EM_ARM) { if (Obj->getHeader()->e_machine != EM_ARM) {
W.startLine() << "Attributes not implemented.\n"; W.startLine() << "Attributes not implemented.\n";
return; return;

8
tools/yaml2obj/yaml2elf.cpp
View File

@ -552,10 +552,10 @@ int yaml2elf(yaml::Input &YIn, raw_ostream &Out) {
return 1; return 1;
} }
using object::ELFType; using object::ELFType;
typedef ELFType<support::little, 8, true> LE64; typedef ELFType<support::little, true> LE64;
typedef ELFType<support::big, 8, true> BE64; typedef ELFType<support::big, true> BE64;
typedef ELFType<support::little, 4, false> LE32; typedef ELFType<support::little, false> LE32;
typedef ELFType<support::big, 4, false> BE32; typedef ELFType<support::big, false> BE32;
if (is64Bit(Doc)) { if (is64Bit(Doc)) {
if (isLittleEndian(Doc)) if (isLittleEndian(Doc))
return ELFState<LE64>::writeELF(Out, Doc); return ELFState<LE64>::writeELF(Out, Doc);