mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 18:54:02 +01:00
[Object] Fix some Clang-tidy modernize and Include What You Use warnings; other minor fixes (NFC).
llvm-svn: 301275
This commit is contained in:
Eugene Zelenko
parent
9a8d6b35cf
commit
e789eacbed
@ -14,9 +14,19 @@
|
||||
#ifndef LLVM_OBJECT_ELF_H
|
||||
#define LLVM_OBJECT_ELF_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Object/ELFTypes.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Object/Error.h"
|
||||
#include "llvm/Support/ELF.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <limits>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
namespace object {
|
||||
@ -41,27 +51,27 @@ template <class ELFT>
|
||||
class ELFFile {
|
||||
public:
|
||||
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
|
||||
typedef typename ELFT::uint uintX_t;
|
||||
typedef typename ELFT::Ehdr Elf_Ehdr;
|
||||
typedef typename ELFT::Shdr Elf_Shdr;
|
||||
typedef typename ELFT::Sym Elf_Sym;
|
||||
typedef typename ELFT::Dyn Elf_Dyn;
|
||||
typedef typename ELFT::Phdr Elf_Phdr;
|
||||
typedef typename ELFT::Rel Elf_Rel;
|
||||
typedef typename ELFT::Rela Elf_Rela;
|
||||
typedef typename ELFT::Verdef Elf_Verdef;
|
||||
typedef typename ELFT::Verdaux Elf_Verdaux;
|
||||
typedef typename ELFT::Verneed Elf_Verneed;
|
||||
typedef typename ELFT::Vernaux Elf_Vernaux;
|
||||
typedef typename ELFT::Versym Elf_Versym;
|
||||
typedef typename ELFT::Hash Elf_Hash;
|
||||
typedef typename ELFT::GnuHash Elf_GnuHash;
|
||||
typedef typename ELFT::DynRange Elf_Dyn_Range;
|
||||
typedef typename ELFT::ShdrRange Elf_Shdr_Range;
|
||||
typedef typename ELFT::SymRange Elf_Sym_Range;
|
||||
typedef typename ELFT::RelRange Elf_Rel_Range;
|
||||
typedef typename ELFT::RelaRange Elf_Rela_Range;
|
||||
typedef typename ELFT::PhdrRange Elf_Phdr_Range;
|
||||
using uintX_t = typename ELFT::uint;
|
||||
using Elf_Ehdr = typename ELFT::Ehdr;
|
||||
using Elf_Shdr = typename ELFT::Shdr;
|
||||
using Elf_Sym = typename ELFT::Sym;
|
||||
using Elf_Dyn = typename ELFT::Dyn;
|
||||
using Elf_Phdr = typename ELFT::Phdr;
|
||||
using Elf_Rel = typename ELFT::Rel;
|
||||
using Elf_Rela = typename ELFT::Rela;
|
||||
using Elf_Verdef = typename ELFT::Verdef;
|
||||
using Elf_Verdaux = typename ELFT::Verdaux;
|
||||
using Elf_Verneed = typename ELFT::Verneed;
|
||||
using Elf_Vernaux = typename ELFT::Vernaux;
|
||||
using Elf_Versym = typename ELFT::Versym;
|
||||
using Elf_Hash = typename ELFT::Hash;
|
||||
using Elf_GnuHash = typename ELFT::GnuHash;
|
||||
using Elf_Dyn_Range = typename ELFT::DynRange;
|
||||
using Elf_Shdr_Range = typename ELFT::ShdrRange;
|
||||
using Elf_Sym_Range = typename ELFT::SymRange;
|
||||
using Elf_Rel_Range = typename ELFT::RelRange;
|
||||
using Elf_Rela_Range = typename ELFT::RelaRange;
|
||||
using Elf_Phdr_Range = typename ELFT::PhdrRange;
|
||||
|
||||
const uint8_t *base() const {
|
||||
return reinterpret_cast<const uint8_t *>(Buf.data());
|
||||
@ -70,7 +80,6 @@ public:
|
||||
size_t getBufSize() const { return Buf.size(); }
|
||||
|
||||
private:
|
||||
|
||||
StringRef Buf;
|
||||
|
||||
public:
|
||||
@ -161,10 +170,10 @@ public:
|
||||
Expected<ArrayRef<uint8_t>> getSectionContents(const Elf_Shdr *Sec) const;
|
||||
};
|
||||
|
||||
typedef ELFFile<ELFType<support::little, false>> ELF32LEFile;
|
||||
typedef ELFFile<ELFType<support::little, true>> ELF64LEFile;
|
||||
typedef ELFFile<ELFType<support::big, false>> ELF32BEFile;
|
||||
typedef ELFFile<ELFType<support::big, true>> ELF64BEFile;
|
||||
using ELF32LEFile = ELFFile<ELFType<support::little, false>>;
|
||||
using ELF64LEFile = ELFFile<ELFType<support::little, true>>;
|
||||
using ELF32BEFile = ELFFile<ELFType<support::big, false>>;
|
||||
using ELF64BEFile = ELFFile<ELFType<support::big, true>>;
|
||||
|
||||
template <class ELFT>
|
||||
inline Expected<const typename ELFT::Shdr *>
|
||||
@ -194,7 +203,7 @@ ELFFile<ELFT>::getSectionIndex(const Elf_Sym *Sym, Elf_Sym_Range Syms,
|
||||
ArrayRef<Elf_Word> ShndxTable) const {
|
||||
uint32_t Index = Sym->st_shndx;
|
||||
if (Index == ELF::SHN_XINDEX) {
|
||||
auto ErrorOrIndex = object::getExtendedSymbolTableIndex<ELFT>(
|
||||
auto ErrorOrIndex = getExtendedSymbolTableIndex<ELFT>(
|
||||
Sym, Syms.begin(), ShndxTable);
|
||||
if (!ErrorOrIndex)
|
||||
return ErrorOrIndex.takeError();
|
||||
@ -519,7 +528,8 @@ inline unsigned hashSysV(StringRef SymbolName) {
|
||||
}
|
||||
return h;
|
||||
}
|
||||
|
||||
} // end namespace object
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_OBJECT_ELF_H
|
||||
|
||||
@ -27,6 +27,7 @@
|
||||
#include "llvm/Object/ObjectFile.h"
|
||||
#include "llvm/Object/SymbolicFile.h"
|
||||
#include "llvm/Support/ARMAttributeParser.h"
|
||||
#include "llvm/Support/ARMBuildAttributes.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/ELF.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
@ -42,13 +43,11 @@ namespace llvm {
|
||||
namespace object {
|
||||
|
||||
class elf_symbol_iterator;
|
||||
class ELFSymbolRef;
|
||||
class ELFRelocationRef;
|
||||
|
||||
class ELFObjectFileBase : public ObjectFile {
|
||||
friend class ELFSymbolRef;
|
||||
friend class ELFSectionRef;
|
||||
friend class ELFRelocationRef;
|
||||
friend class ELFSectionRef;
|
||||
friend class ELFSymbolRef;
|
||||
|
||||
protected:
|
||||
ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source);
|
||||
@ -65,7 +64,8 @@ protected:
|
||||
virtual ErrorOr<int64_t> getRelocationAddend(DataRefImpl Rel) const = 0;
|
||||
|
||||
public:
|
||||
typedef iterator_range<elf_symbol_iterator> elf_symbol_iterator_range;
|
||||
using elf_symbol_iterator_range = iterator_range<elf_symbol_iterator>;
|
||||
|
||||
virtual elf_symbol_iterator_range getDynamicSymbolIterators() const = 0;
|
||||
|
||||
elf_symbol_iterator_range symbols() const;
|
||||
@ -201,14 +201,14 @@ template <class ELFT> class ELFObjectFile : public ELFObjectFileBase {
|
||||
public:
|
||||
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
|
||||
|
||||
typedef typename ELFFile<ELFT>::uintX_t uintX_t;
|
||||
using uintX_t = typename ELFFile<ELFT>::uintX_t;
|
||||
|
||||
typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
|
||||
typedef typename ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
|
||||
typedef typename ELFFile<ELFT>::Elf_Ehdr Elf_Ehdr;
|
||||
typedef typename ELFFile<ELFT>::Elf_Rel Elf_Rel;
|
||||
typedef typename ELFFile<ELFT>::Elf_Rela Elf_Rela;
|
||||
typedef typename ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
|
||||
using Elf_Sym = typename ELFFile<ELFT>::Elf_Sym;
|
||||
using Elf_Shdr = typename ELFFile<ELFT>::Elf_Shdr;
|
||||
using Elf_Ehdr = typename ELFFile<ELFT>::Elf_Ehdr;
|
||||
using Elf_Rel = typename ELFFile<ELFT>::Elf_Rel;
|
||||
using Elf_Rela = typename ELFFile<ELFT>::Elf_Rela;
|
||||
using Elf_Dyn = typename ELFFile<ELFT>::Elf_Dyn;
|
||||
|
||||
protected:
|
||||
ELFFile<ELFT> EF;
|
||||
@ -398,10 +398,10 @@ public:
|
||||
bool isRelocatableObject() const override;
|
||||
};
|
||||
|
||||
typedef ELFObjectFile<ELFType<support::little, false>> ELF32LEObjectFile;
|
||||
typedef ELFObjectFile<ELFType<support::little, true>> ELF64LEObjectFile;
|
||||
typedef ELFObjectFile<ELFType<support::big, false>> ELF32BEObjectFile;
|
||||
typedef ELFObjectFile<ELFType<support::big, true>> ELF64BEObjectFile;
|
||||
using ELF32LEObjectFile = ELFObjectFile<ELFType<support::little, false>>;
|
||||
using ELF64LEObjectFile = ELFObjectFile<ELFType<support::little, true>>;
|
||||
using ELF32BEObjectFile = ELFObjectFile<ELFType<support::big, false>>;
|
||||
using ELF64BEObjectFile = ELFObjectFile<ELFType<support::big, true>>;
|
||||
|
||||
template <class ELFT>
|
||||
void ELFObjectFile<ELFT>::moveSymbolNext(DataRefImpl &Sym) const {
|
||||
|
||||
@ -11,10 +11,15 @@
|
||||
#define LLVM_OBJECT_ELFTYPES_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Object/Error.h"
|
||||
#include "llvm/Support/ELF.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/ErrorOr.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llvm {
|
||||
namespace object {
|
||||
@ -45,58 +50,58 @@ public:
|
||||
static const endianness TargetEndianness = E;
|
||||
static const bool Is64Bits = Is64;
|
||||
|
||||
typedef typename std::conditional<Is64, uint64_t, uint32_t>::type uint;
|
||||
typedef Elf_Ehdr_Impl<ELFType<E, Is64>> Ehdr;
|
||||
typedef Elf_Shdr_Impl<ELFType<E, Is64>> Shdr;
|
||||
typedef Elf_Sym_Impl<ELFType<E, Is64>> Sym;
|
||||
typedef Elf_Dyn_Impl<ELFType<E, Is64>> Dyn;
|
||||
typedef Elf_Phdr_Impl<ELFType<E, Is64>> Phdr;
|
||||
typedef Elf_Rel_Impl<ELFType<E, Is64>, false> Rel;
|
||||
typedef Elf_Rel_Impl<ELFType<E, Is64>, true> Rela;
|
||||
typedef Elf_Verdef_Impl<ELFType<E, Is64>> Verdef;
|
||||
typedef Elf_Verdaux_Impl<ELFType<E, Is64>> Verdaux;
|
||||
typedef Elf_Verneed_Impl<ELFType<E, Is64>> Verneed;
|
||||
typedef Elf_Vernaux_Impl<ELFType<E, Is64>> Vernaux;
|
||||
typedef Elf_Versym_Impl<ELFType<E, Is64>> Versym;
|
||||
typedef Elf_Hash_Impl<ELFType<E, Is64>> Hash;
|
||||
typedef Elf_GnuHash_Impl<ELFType<E, Is64>> GnuHash;
|
||||
typedef Elf_Chdr_Impl<ELFType<E, Is64>> Chdr;
|
||||
typedef ArrayRef<Dyn> DynRange;
|
||||
typedef ArrayRef<Shdr> ShdrRange;
|
||||
typedef ArrayRef<Sym> SymRange;
|
||||
typedef ArrayRef<Rel> RelRange;
|
||||
typedef ArrayRef<Rela> RelaRange;
|
||||
typedef ArrayRef<Phdr> PhdrRange;
|
||||
using uint = typename std::conditional<Is64, uint64_t, uint32_t>::type;
|
||||
using Ehdr = Elf_Ehdr_Impl<ELFType<E, Is64>>;
|
||||
using Shdr = Elf_Shdr_Impl<ELFType<E, Is64>>;
|
||||
using Sym = Elf_Sym_Impl<ELFType<E, Is64>>;
|
||||
using Dyn = Elf_Dyn_Impl<ELFType<E, Is64>>;
|
||||
using Phdr = Elf_Phdr_Impl<ELFType<E, Is64>>;
|
||||
using Rel = Elf_Rel_Impl<ELFType<E, Is64>, false>;
|
||||
using Rela = Elf_Rel_Impl<ELFType<E, Is64>, true>;
|
||||
using Verdef = Elf_Verdef_Impl<ELFType<E, Is64>>;
|
||||
using Verdaux = Elf_Verdaux_Impl<ELFType<E, Is64>>;
|
||||
using Verneed = Elf_Verneed_Impl<ELFType<E, Is64>>;
|
||||
using Vernaux = Elf_Vernaux_Impl<ELFType<E, Is64>>;
|
||||
using Versym = Elf_Versym_Impl<ELFType<E, Is64>>;
|
||||
using Hash = Elf_Hash_Impl<ELFType<E, Is64>>;
|
||||
using GnuHash = Elf_GnuHash_Impl<ELFType<E, Is64>>;
|
||||
using Chdr = Elf_Chdr_Impl<ELFType<E, Is64>>;
|
||||
using DynRange = ArrayRef<Dyn>;
|
||||
using ShdrRange = ArrayRef<Shdr>;
|
||||
using SymRange = ArrayRef<Sym>;
|
||||
using RelRange = ArrayRef<Rel>;
|
||||
using RelaRange = ArrayRef<Rela>;
|
||||
using PhdrRange = ArrayRef<Phdr>;
|
||||
|
||||
typedef packed<uint16_t> Half;
|
||||
typedef packed<uint32_t> Word;
|
||||
typedef packed<int32_t> Sword;
|
||||
typedef packed<uint64_t> Xword;
|
||||
typedef packed<int64_t> Sxword;
|
||||
typedef packed<uint> Addr;
|
||||
typedef packed<uint> Off;
|
||||
using Half = packed<uint16_t>;
|
||||
using Word = packed<uint32_t>;
|
||||
using Sword = packed<int32_t>;
|
||||
using Xword = packed<uint64_t>;
|
||||
using Sxword = packed<int64_t>;
|
||||
using Addr = packed<uint>;
|
||||
using Off = packed<uint>;
|
||||
};
|
||||
|
||||
typedef ELFType<support::little, false> ELF32LE;
|
||||
typedef ELFType<support::big, false> ELF32BE;
|
||||
typedef ELFType<support::little, true> ELF64LE;
|
||||
typedef ELFType<support::big, true> ELF64BE;
|
||||
using ELF32LE = ELFType<support::little, false>;
|
||||
using ELF32BE = ELFType<support::big, false>;
|
||||
using ELF64LE = ELFType<support::little, true>;
|
||||
using ELF64BE = ELFType<support::big, true>;
|
||||
|
||||
// Use an alignment of 2 for the typedefs since that is the worst case for
|
||||
// ELF files in archives.
|
||||
|
||||
// Templates to choose Elf_Addr and Elf_Off depending on is64Bits.
|
||||
template <endianness target_endianness> struct ELFDataTypeTypedefHelperCommon {
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
uint16_t, target_endianness, 2> Elf_Half;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
uint32_t, target_endianness, 2> Elf_Word;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
int32_t, target_endianness, 2> Elf_Sword;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
uint64_t, target_endianness, 2> Elf_Xword;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
int64_t, target_endianness, 2> Elf_Sxword;
|
||||
using Elf_Half = support::detail::packed_endian_specific_integral<
|
||||
uint16_t, target_endianness, 2>;
|
||||
using Elf_Word = support::detail::packed_endian_specific_integral<
|
||||
uint32_t, target_endianness, 2>;
|
||||
using Elf_Sword = support::detail::packed_endian_specific_integral<
|
||||
int32_t, target_endianness, 2>;
|
||||
using Elf_Xword = support::detail::packed_endian_specific_integral<
|
||||
uint64_t, target_endianness, 2>;
|
||||
using Elf_Sxword = support::detail::packed_endian_specific_integral<
|
||||
int64_t, target_endianness, 2>;
|
||||
};
|
||||
|
||||
template <class ELFT> struct ELFDataTypeTypedefHelper;
|
||||
@ -105,34 +110,34 @@ template <class ELFT> struct ELFDataTypeTypedefHelper;
|
||||
template <endianness TargetEndianness>
|
||||
struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, false>>
|
||||
: ELFDataTypeTypedefHelperCommon<TargetEndianness> {
|
||||
typedef uint32_t value_type;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2> Elf_Addr;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2> Elf_Off;
|
||||
using value_type = uint32_t;
|
||||
using Elf_Addr = support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2>;
|
||||
using Elf_Off = support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2>;
|
||||
};
|
||||
|
||||
/// ELF 64bit types.
|
||||
template <endianness TargetEndianness>
|
||||
struct ELFDataTypeTypedefHelper<ELFType<TargetEndianness, true>>
|
||||
: ELFDataTypeTypedefHelperCommon<TargetEndianness> {
|
||||
typedef uint64_t value_type;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2> Elf_Addr;
|
||||
typedef support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2> Elf_Off;
|
||||
using value_type = uint64_t;
|
||||
using Elf_Addr = support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2>;
|
||||
using Elf_Off = support::detail::packed_endian_specific_integral<
|
||||
value_type, TargetEndianness, 2>;
|
||||
};
|
||||
|
||||
// I really don't like doing this, but the alternative is copypasta.
|
||||
|
||||
#define LLVM_ELF_IMPORT_TYPES_ELFT(ELFT) \
|
||||
typedef typename ELFT::Addr Elf_Addr; \
|
||||
typedef typename ELFT::Off Elf_Off; \
|
||||
typedef typename ELFT::Half Elf_Half; \
|
||||
typedef typename ELFT::Word Elf_Word; \
|
||||
typedef typename ELFT::Sword Elf_Sword; \
|
||||
typedef typename ELFT::Xword Elf_Xword; \
|
||||
typedef typename ELFT::Sxword Elf_Sxword;
|
||||
using Elf_Addr = typename ELFT::Addr; \
|
||||
using Elf_Off = typename ELFT::Off; \
|
||||
using Elf_Half = typename ELFT::Half; \
|
||||
using Elf_Word = typename ELFT::Word; \
|
||||
using Elf_Sword = typename ELFT::Sword; \
|
||||
using Elf_Xword = typename ELFT::Xword; \
|
||||
using Elf_Sxword = typename ELFT::Sxword;
|
||||
|
||||
#define LLD_ELF_COMMA ,
|
||||
#define LLVM_ELF_IMPORT_TYPES(E, W) \
|
||||
@ -222,6 +227,7 @@ struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
|
||||
uint64_t getValue() const { return st_value; }
|
||||
void setBinding(unsigned char b) { setBindingAndType(b, getType()); }
|
||||
void setType(unsigned char t) { setBindingAndType(getBinding(), t); }
|
||||
|
||||
void setBindingAndType(unsigned char b, unsigned char t) {
|
||||
st_info = (b << 4) + (t & 0x0f);
|
||||
}
|
||||
@ -238,22 +244,29 @@ struct Elf_Sym_Impl : Elf_Sym_Base<ELFT> {
|
||||
}
|
||||
|
||||
bool isAbsolute() const { return st_shndx == ELF::SHN_ABS; }
|
||||
|
||||
bool isCommon() const {
|
||||
return getType() == ELF::STT_COMMON || st_shndx == ELF::SHN_COMMON;
|
||||
}
|
||||
|
||||
bool isDefined() const { return !isUndefined(); }
|
||||
|
||||
bool isProcessorSpecific() const {
|
||||
return st_shndx >= ELF::SHN_LOPROC && st_shndx <= ELF::SHN_HIPROC;
|
||||
}
|
||||
|
||||
bool isOSSpecific() const {
|
||||
return st_shndx >= ELF::SHN_LOOS && st_shndx <= ELF::SHN_HIOS;
|
||||
}
|
||||
|
||||
bool isReserved() const {
|
||||
// ELF::SHN_HIRESERVE is 0xffff so st_shndx <= ELF::SHN_HIRESERVE is always
|
||||
// true and some compilers warn about it.
|
||||
return st_shndx >= ELF::SHN_LORESERVE;
|
||||
}
|
||||
|
||||
bool isUndefined() const { return st_shndx == ELF::SHN_UNDEF; }
|
||||
|
||||
bool isExternal() const {
|
||||
return getBinding() != ELF::STB_LOCAL;
|
||||
}
|
||||
@ -277,14 +290,12 @@ struct Elf_Versym_Impl {
|
||||
Elf_Half vs_index; // Version index with flags (e.g. VERSYM_HIDDEN)
|
||||
};
|
||||
|
||||
template <class ELFT> struct Elf_Verdaux_Impl;
|
||||
|
||||
/// Elf_Verdef: This is the structure of entries in the SHT_GNU_verdef section
|
||||
/// (.gnu.version_d). This structure is identical for ELF32 and ELF64.
|
||||
template <class ELFT>
|
||||
struct Elf_Verdef_Impl {
|
||||
LLVM_ELF_IMPORT_TYPES_ELFT(ELFT)
|
||||
typedef Elf_Verdaux_Impl<ELFT> Elf_Verdaux;
|
||||
using Elf_Verdaux = Elf_Verdaux_Impl<ELFT>;
|
||||
Elf_Half vd_version; // Version of this structure (e.g. VER_DEF_CURRENT)
|
||||
Elf_Half vd_flags; // Bitwise flags (VER_DEF_*)
|
||||
Elf_Half vd_ndx; // Version index, used in .gnu.version entries
|
||||
@ -361,10 +372,10 @@ template <class ELFT>
|
||||
struct Elf_Dyn_Impl : Elf_Dyn_Base<ELFT> {
|
||||
using Elf_Dyn_Base<ELFT>::d_tag;
|
||||
using Elf_Dyn_Base<ELFT>::d_un;
|
||||
typedef typename std::conditional<ELFT::Is64Bits,
|
||||
int64_t, int32_t>::type intX_t;
|
||||
typedef typename std::conditional<ELFT::Is64Bits,
|
||||
uint64_t, uint32_t>::type uintX_t;
|
||||
using intX_t = typename std::conditional<ELFT::Is64Bits,
|
||||
int64_t, int32_t>::type;
|
||||
using uintX_t = typename std::conditional<ELFT::Is64Bits,
|
||||
uint64_t, uint32_t>::type;
|
||||
intX_t getTag() const { return d_tag; }
|
||||
uintX_t getVal() const { return d_un.d_val; }
|
||||
uintX_t getPtr() const { return d_un.d_ptr; }
|
||||
@ -430,6 +441,7 @@ struct Elf_Rel_Impl<ELFType<TargetEndianness, true>, false> {
|
||||
return (t << 32) | ((t >> 8) & 0xff000000) | ((t >> 24) & 0x00ff0000) |
|
||||
((t >> 40) & 0x0000ff00) | ((t >> 56) & 0x000000ff);
|
||||
}
|
||||
|
||||
void setRInfo(uint64_t R, bool IsMips64EL) {
|
||||
if (IsMips64EL)
|
||||
r_info = (R >> 32) | ((R & 0xff000000) << 8) | ((R & 0x00ff0000) << 24) |
|
||||
@ -483,15 +495,15 @@ struct Elf_Ehdr_Impl {
|
||||
Elf_Half e_shnum; // Number of entries in the section header table
|
||||
Elf_Half e_shstrndx; // Section header table index of section name
|
||||
// string table
|
||||
|
||||
bool checkMagic() const {
|
||||
return (memcmp(e_ident, ELF::ElfMagic, strlen(ELF::ElfMagic))) == 0;
|
||||
}
|
||||
|
||||
unsigned char getFileClass() const { return e_ident[ELF::EI_CLASS]; }
|
||||
unsigned char getDataEncoding() const { return e_ident[ELF::EI_DATA]; }
|
||||
};
|
||||
|
||||
template <class ELFT> struct Elf_Phdr_Impl;
|
||||
|
||||
template <endianness TargetEndianness>
|
||||
struct Elf_Phdr_Impl<ELFType<TargetEndianness, false>> {
|
||||
LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
|
||||
@ -582,7 +594,7 @@ struct Elf_Chdr_Impl<ELFType<TargetEndianness, true>> {
|
||||
template <class ELFT>
|
||||
struct Elf_Mips_RegInfo;
|
||||
|
||||
template <llvm::support::endianness TargetEndianness>
|
||||
template <support::endianness TargetEndianness>
|
||||
struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
|
||||
LLVM_ELF_IMPORT_TYPES(TargetEndianness, false)
|
||||
Elf_Word ri_gprmask; // bit-mask of used general registers
|
||||
@ -590,7 +602,7 @@ struct Elf_Mips_RegInfo<ELFType<TargetEndianness, false>> {
|
||||
Elf_Addr ri_gp_value; // gp register value
|
||||
};
|
||||
|
||||
template <llvm::support::endianness TargetEndianness>
|
||||
template <support::endianness TargetEndianness>
|
||||
struct Elf_Mips_RegInfo<ELFType<TargetEndianness, true>> {
|
||||
LLVM_ELF_IMPORT_TYPES(TargetEndianness, true)
|
||||
Elf_Word ri_gprmask; // bit-mask of used general registers
|
||||
@ -609,7 +621,7 @@ template <class ELFT> struct Elf_Mips_Options {
|
||||
Elf_Word info; // Kind-specific information
|
||||
|
||||
Elf_Mips_RegInfo<ELFT> &getRegInfo() {
|
||||
assert(kind == llvm::ELF::ODK_REGINFO);
|
||||
assert(kind == ELF::ODK_REGINFO);
|
||||
return *reinterpret_cast<Elf_Mips_RegInfo<ELFT> *>(
|
||||
(uint8_t *)this + sizeof(Elf_Mips_Options));
|
||||
}
|
||||
@ -637,4 +649,4 @@ template <class ELFT> struct Elf_Mips_ABIFlags {
|
||||
} // end namespace object.
|
||||
} // end namespace llvm.
|
||||
|
||||
#endif
|
||||
#endif // LLVM_OBJECT_ELFTYPES_H
|
||||
|
||||
@ -25,23 +25,31 @@
|
||||
#define LLVM_OBJECT_IRSYMTAB_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/IR/GlobalValue.h"
|
||||
#include "llvm/Object/SymbolicFile.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
namespace irsymtab {
|
||||
|
||||
namespace storage {
|
||||
|
||||
// The data structures in this namespace define the low-level serialization
|
||||
// format. Clients that just want to read a symbol table should use the
|
||||
// irsymtab::Reader class.
|
||||
|
||||
typedef support::ulittle32_t Word;
|
||||
using Word = support::ulittle32_t;
|
||||
|
||||
/// A reference to a string in the string table.
|
||||
struct Str {
|
||||
Word Offset, Size;
|
||||
|
||||
StringRef get(StringRef Strtab) const {
|
||||
return {Strtab.data() + Offset, Size};
|
||||
}
|
||||
@ -50,6 +58,7 @@ struct Str {
|
||||
/// A reference to a range of objects in the symbol table.
|
||||
template <typename T> struct Range {
|
||||
Word Offset, Size;
|
||||
|
||||
ArrayRef<T> get(StringRef Symtab) const {
|
||||
return {reinterpret_cast<const T *>(Symtab.data() + Offset), Size};
|
||||
}
|
||||
@ -122,7 +131,7 @@ struct Header {
|
||||
Str COFFLinkerOpts;
|
||||
};
|
||||
|
||||
}
|
||||
} // end namespace storage
|
||||
|
||||
/// Fills in Symtab and Strtab with a valid symbol and string table for Mods.
|
||||
Error build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
|
||||
@ -152,18 +161,22 @@ struct Symbol {
|
||||
int getComdatIndex() const { return ComdatIndex; }
|
||||
|
||||
using S = storage::Symbol;
|
||||
|
||||
GlobalValue::VisibilityTypes getVisibility() const {
|
||||
return GlobalValue::VisibilityTypes((Flags >> S::FB_visibility) & 3);
|
||||
}
|
||||
|
||||
bool isUndefined() const { return (Flags >> S::FB_undefined) & 1; }
|
||||
bool isWeak() const { return (Flags >> S::FB_weak) & 1; }
|
||||
bool isCommon() const { return (Flags >> S::FB_common) & 1; }
|
||||
bool isIndirect() const { return (Flags >> S::FB_indirect) & 1; }
|
||||
bool isUsed() const { return (Flags >> S::FB_used) & 1; }
|
||||
bool isTLS() const { return (Flags >> S::FB_tls) & 1; }
|
||||
|
||||
bool canBeOmittedFromSymbolTable() const {
|
||||
return (Flags >> S::FB_may_omit) & 1;
|
||||
}
|
||||
|
||||
bool isGlobal() const { return (Flags >> S::FB_global) & 1; }
|
||||
bool isFormatSpecific() const { return (Flags >> S::FB_format_specific) & 1; }
|
||||
bool isUnnamedAddr() const { return (Flags >> S::FB_unnamed_addr) & 1; }
|
||||
@ -173,6 +186,7 @@ struct Symbol {
|
||||
assert(isCommon());
|
||||
return CommonSize;
|
||||
}
|
||||
|
||||
uint32_t getCommonAlignment() const {
|
||||
assert(isCommon());
|
||||
return CommonAlign;
|
||||
@ -197,9 +211,11 @@ class Reader {
|
||||
ArrayRef<storage::Uncommon> Uncommons;
|
||||
|
||||
StringRef str(storage::Str S) const { return S.get(Strtab); }
|
||||
|
||||
template <typename T> ArrayRef<T> range(storage::Range<T> R) const {
|
||||
return R.get(Symtab);
|
||||
}
|
||||
|
||||
const storage::Header &header() const {
|
||||
return *reinterpret_cast<const storage::Header *>(Symtab.data());
|
||||
}
|
||||
@ -215,7 +231,7 @@ public:
|
||||
Uncommons = range(header().Uncommons);
|
||||
}
|
||||
|
||||
typedef iterator_range<object::content_iterator<SymbolRef>> symbol_range;
|
||||
using symbol_range = iterator_range<object::content_iterator<SymbolRef>>;
|
||||
|
||||
/// Returns the symbol table for the entire bitcode file.
|
||||
/// The symbols enumerated by this method are ephemeral, but they can be
|
||||
@ -298,8 +314,7 @@ inline Reader::symbol_range Reader::module_symbols(unsigned I) const {
|
||||
SymbolRef(MEnd, MEnd, nullptr, this)};
|
||||
}
|
||||
|
||||
}
|
||||
} // end namespace irsymtab
|
||||
} // end namespace llvm
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif // LLVM_OBJECT_IRSYMTAB_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- ModuleSymbolTable.h - symbol table for in-memory IR ----------------===//
|
||||
//===- ModuleSymbolTable.h - symbol table for in-memory IR ------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -16,22 +16,24 @@
|
||||
#ifndef LLVM_OBJECT_MODULESYMBOLTABLE_H
|
||||
#define LLVM_OBJECT_MODULESYMBOLTABLE_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/PointerUnion.h"
|
||||
#include "llvm/ADT/Triple.h"
|
||||
#include "llvm/IR/Mangler.h"
|
||||
#include "llvm/Object/SymbolicFile.h"
|
||||
#include "llvm/Support/Allocator.h"
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class GlobalValue;
|
||||
class RecordStreamer;
|
||||
|
||||
class ModuleSymbolTable {
|
||||
public:
|
||||
typedef std::pair<std::string, uint32_t> AsmSymbol;
|
||||
typedef PointerUnion<GlobalValue *, AsmSymbol *> Symbol;
|
||||
using AsmSymbol = std::pair<std::string, uint32_t>;
|
||||
using Symbol = PointerUnion<GlobalValue *, AsmSymbol *>;
|
||||
|
||||
private:
|
||||
Module *FirstMod = nullptr;
|
||||
@ -57,6 +59,6 @@ public:
|
||||
function_ref<void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol);
|
||||
};
|
||||
|
||||
}
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_OBJECT_MODULESYMBOLTABLE_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-------- StackMapParser.h - StackMap Parsing Support -------*- C++ -*-===//
|
||||
//===- StackMapParser.h - StackMap Parsing Support --------------*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -11,7 +11,11 @@
|
||||
#define LLVM_CODEGEN_STACKMAPPARSER_H
|
||||
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/iterator_range.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include <cassert>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
@ -19,12 +23,11 @@ namespace llvm {
|
||||
template <support::endianness Endianness>
|
||||
class StackMapV2Parser {
|
||||
public:
|
||||
|
||||
template <typename AccessorT>
|
||||
class AccessorIterator {
|
||||
public:
|
||||
|
||||
AccessorIterator(AccessorT A) : A(A) {}
|
||||
|
||||
AccessorIterator& operator++() { A = A.next(); return *this; }
|
||||
AccessorIterator operator++(int) {
|
||||
auto tmp = *this;
|
||||
@ -48,8 +51,8 @@ public:
|
||||
/// Accessor for function records.
|
||||
class FunctionAccessor {
|
||||
friend class StackMapV2Parser;
|
||||
public:
|
||||
|
||||
public:
|
||||
/// Get the function address.
|
||||
uint64_t getFunctionAddress() const {
|
||||
return read<uint64_t>(P);
|
||||
@ -80,13 +83,12 @@ public:
|
||||
/// Accessor for constants.
|
||||
class ConstantAccessor {
|
||||
friend class StackMapV2Parser;
|
||||
public:
|
||||
|
||||
public:
|
||||
/// Return the value of this constant.
|
||||
uint64_t getValue() const { return read<uint64_t>(P); }
|
||||
|
||||
private:
|
||||
|
||||
ConstantAccessor(const uint8_t *P) : P(P) {}
|
||||
|
||||
const static int ConstantAccessorSize = sizeof(uint64_t);
|
||||
@ -98,20 +100,16 @@ public:
|
||||
const uint8_t *P;
|
||||
};
|
||||
|
||||
// Forward-declare RecordAccessor so we can friend it below.
|
||||
class RecordAccessor;
|
||||
|
||||
enum class LocationKind : uint8_t {
|
||||
Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5
|
||||
};
|
||||
|
||||
|
||||
/// Accessor for location records.
|
||||
class LocationAccessor {
|
||||
friend class StackMapV2Parser;
|
||||
friend class RecordAccessor;
|
||||
public:
|
||||
|
||||
public:
|
||||
/// Get the Kind for this location.
|
||||
LocationKind getKind() const {
|
||||
return LocationKind(P[KindOffset]);
|
||||
@ -144,7 +142,6 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
LocationAccessor(const uint8_t *P) : P(P) {}
|
||||
|
||||
LocationAccessor next() const {
|
||||
@ -163,8 +160,8 @@ public:
|
||||
class LiveOutAccessor {
|
||||
friend class StackMapV2Parser;
|
||||
friend class RecordAccessor;
|
||||
public:
|
||||
|
||||
public:
|
||||
/// Get the Dwarf register number for this live-out.
|
||||
uint16_t getDwarfRegNum() const {
|
||||
return read<uint16_t>(P + DwarfRegNumOffset);
|
||||
@ -176,7 +173,6 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
LiveOutAccessor(const uint8_t *P) : P(P) {}
|
||||
|
||||
LiveOutAccessor next() const {
|
||||
@ -194,10 +190,10 @@ public:
|
||||
/// Accessor for stackmap records.
|
||||
class RecordAccessor {
|
||||
friend class StackMapV2Parser;
|
||||
public:
|
||||
|
||||
typedef AccessorIterator<LocationAccessor> location_iterator;
|
||||
typedef AccessorIterator<LiveOutAccessor> liveout_iterator;
|
||||
public:
|
||||
using location_iterator = AccessorIterator<LocationAccessor>;
|
||||
using liveout_iterator = AccessorIterator<LiveOutAccessor>;
|
||||
|
||||
/// Get the patchpoint/stackmap ID for this record.
|
||||
uint64_t getID() const {
|
||||
@ -254,7 +250,6 @@ public:
|
||||
return liveout_iterator(getLiveOut(0));
|
||||
}
|
||||
|
||||
|
||||
/// End iterator for live-outs.
|
||||
liveout_iterator liveouts_end() const {
|
||||
return liveout_iterator(getLiveOut(getNumLiveOuts()));
|
||||
@ -266,7 +261,6 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
RecordAccessor(const uint8_t *P) : P(P) {}
|
||||
|
||||
unsigned getNumLiveOutsOffset() const {
|
||||
@ -316,9 +310,9 @@ public:
|
||||
}
|
||||
}
|
||||
|
||||
typedef AccessorIterator<FunctionAccessor> function_iterator;
|
||||
typedef AccessorIterator<ConstantAccessor> constant_iterator;
|
||||
typedef AccessorIterator<RecordAccessor> record_iterator;
|
||||
using function_iterator = AccessorIterator<FunctionAccessor>;
|
||||
using constant_iterator = AccessorIterator<ConstantAccessor>;
|
||||
using record_iterator = AccessorIterator<RecordAccessor>;
|
||||
|
||||
/// Get the version number of this stackmap. (Always returns 2).
|
||||
unsigned getVersion() const { return 2; }
|
||||
@ -413,7 +407,6 @@ public:
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
template <typename T>
|
||||
static T read(const uint8_t *P) {
|
||||
return support::endian::read<T, Endianness, 1>(P);
|
||||
@ -441,6 +434,6 @@ private:
|
||||
std::vector<unsigned> StackMapRecordOffsets;
|
||||
};
|
||||
|
||||
}
|
||||
} // end namespace llvm
|
||||
|
||||
#endif
|
||||
#endif // LLVM_CODEGEN_STACKMAPPARSER_H
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- ELF.cpp - ELF object file implementation -----------------*- C++ -*-===//
|
||||
//===- ELF.cpp - ELF object file implementation ---------------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -8,15 +8,17 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Object/ELF.h"
|
||||
#include "llvm/Support/ELF.h"
|
||||
|
||||
namespace llvm {
|
||||
namespace object {
|
||||
using namespace llvm;
|
||||
using namespace object;
|
||||
|
||||
#define ELF_RELOC(name, value) \
|
||||
case ELF::name: \
|
||||
return #name; \
|
||||
|
||||
StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type) {
|
||||
StringRef llvm::object::getELFRelocationTypeName(uint32_t Machine,
|
||||
uint32_t Type) {
|
||||
switch (Machine) {
|
||||
case ELF::EM_X86_64:
|
||||
switch (Type) {
|
||||
@ -139,6 +141,3 @@ StringRef getELFRelocationTypeName(uint32_t Machine, uint32_t Type) {
|
||||
}
|
||||
|
||||
#undef ELF_RELOC
|
||||
|
||||
} // end namespace object
|
||||
} // end namespace llvm
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- ELFObjectFile.cpp - ELF object file implementation -------*- C++ -*-===//
|
||||
//===- ELFObjectFile.cpp - ELF object file implementation -----------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -11,12 +11,27 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/ADT/Triple.h"
|
||||
#include "llvm/MC/SubtargetFeature.h"
|
||||
#include "llvm/Object/ELF.h"
|
||||
#include "llvm/Object/ELFObjectFile.h"
|
||||
#include "llvm/Object/ELFTypes.h"
|
||||
#include "llvm/Object/Error.h"
|
||||
#include "llvm/Support/ARMBuildAttributes.h"
|
||||
#include "llvm/Support/ARMAttributeParser.h"
|
||||
#include "llvm/Support/ELF.h"
|
||||
#include "llvm/Support/Endian.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include <algorithm>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <system_error>
|
||||
#include <utility>
|
||||
|
||||
namespace llvm {
|
||||
using namespace llvm;
|
||||
using namespace object;
|
||||
|
||||
ELFObjectFileBase::ELFObjectFileBase(unsigned int Type, MemoryBufferRef Source)
|
||||
@ -299,5 +314,3 @@ void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const {
|
||||
|
||||
TheTriple.setArchName(Triple);
|
||||
}
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- IRSymtab.cpp - implementation of IR symbol tables --------*- C++ -*-===//
|
||||
//===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -7,14 +7,34 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Object/IRSymtab.h"
|
||||
#include "llvm/ADT/ArrayRef.h"
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/SmallPtrSet.h"
|
||||
#include "llvm/ADT/SmallString.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/ADT/Triple.h"
|
||||
#include "llvm/Analysis/ObjectUtils.h"
|
||||
#include "llvm/IR/Comdat.h"
|
||||
#include "llvm/IR/DataLayout.h"
|
||||
#include "llvm/IR/GlobalAlias.h"
|
||||
#include "llvm/IR/GlobalObject.h"
|
||||
#include "llvm/IR/Mangler.h"
|
||||
#include "llvm/IR/Metadata.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/MC/StringTableBuilder.h"
|
||||
#include "llvm/Object/IRSymtab.h"
|
||||
#include "llvm/Object/ModuleSymbolTable.h"
|
||||
#include "llvm/Object/SymbolicFile.h"
|
||||
#include "llvm/Support/Allocator.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/Error.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Support/StringSaver.h"
|
||||
#include <cassert>
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
using namespace llvm;
|
||||
using namespace irsymtab;
|
||||
@ -25,6 +45,7 @@ namespace {
|
||||
struct Builder {
|
||||
SmallVector<char, 0> &Symtab;
|
||||
SmallVector<char, 0> &Strtab;
|
||||
|
||||
Builder(SmallVector<char, 0> &Symtab, SmallVector<char, 0> &Strtab)
|
||||
: Symtab(Symtab), Strtab(Strtab) {}
|
||||
|
||||
@ -49,6 +70,7 @@ struct Builder {
|
||||
S.Offset = StrtabBuilder.add(Value);
|
||||
S.Size = Value.size();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
|
||||
R.Offset = Symtab.size();
|
||||
@ -228,7 +250,7 @@ Error Builder::build(ArrayRef<Module *> IRMods) {
|
||||
return Error::success();
|
||||
}
|
||||
|
||||
} // anonymous namespace
|
||||
} // end anonymous namespace
|
||||
|
||||
Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
|
||||
SmallVector<char, 0> &Strtab) {
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===- ModuleSymbolTable.cpp - symbol table for in-memory IR ----*- C++ -*-===//
|
||||
//===- ModuleSymbolTable.cpp - symbol table for in-memory IR --------------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -13,27 +13,45 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Object/IRObjectFile.h"
|
||||
#include "RecordStreamer.h"
|
||||
#include "llvm/ADT/SmallString.h"
|
||||
#include "llvm/ADT/STLExtras.h"
|
||||
#include "llvm/Bitcode/BitcodeReader.h"
|
||||
#include "llvm/IR/GVMaterializer.h"
|
||||
#include "llvm/IR/LLVMContext.h"
|
||||
#include "llvm/ADT/StringMap.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/ADT/Triple.h"
|
||||
#include "llvm/IR/Function.h"
|
||||
#include "llvm/IR/GlobalAlias.h"
|
||||
#include "llvm/IR/GlobalValue.h"
|
||||
#include "llvm/IR/GlobalVariable.h"
|
||||
#include "llvm/IR/Mangler.h"
|
||||
#include "llvm/IR/Module.h"
|
||||
#include "llvm/MC/MCAsmInfo.h"
|
||||
#include "llvm/MC/MCContext.h"
|
||||
#include "llvm/MC/MCDirectives.h"
|
||||
#include "llvm/MC/MCInstrInfo.h"
|
||||
#include "llvm/MC/MCObjectFileInfo.h"
|
||||
#include "llvm/MC/MCParser/MCAsmParser.h"
|
||||
#include "llvm/MC/MCParser/MCTargetAsmParser.h"
|
||||
#include "llvm/MC/MCRegisterInfo.h"
|
||||
#include "llvm/MC/MCSubtargetInfo.h"
|
||||
#include "llvm/Object/ObjectFile.h"
|
||||
#include "llvm/MC/MCSymbol.h"
|
||||
#include "llvm/MC/MCTargetOptions.h"
|
||||
#include "llvm/Object/ModuleSymbolTable.h"
|
||||
#include "llvm/Object/SymbolicFile.h"
|
||||
#include "llvm/Support/Casting.h"
|
||||
#include "llvm/Support/CodeGen.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/Support/SMLoc.h"
|
||||
#include "llvm/Support/SourceMgr.h"
|
||||
#include "llvm/Support/TargetRegistry.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
using namespace llvm;
|
||||
using namespace object;
|
||||
|
||||
|
||||
@ -9,6 +9,7 @@
|
||||
|
||||
#include "RecordStreamer.h"
|
||||
#include "llvm/MC/MCSymbol.h"
|
||||
|
||||
using namespace llvm;
|
||||
|
||||
void RecordStreamer::markDefined(const MCSymbol &Symbol) {
|
||||
@ -69,14 +70,14 @@ void RecordStreamer::markUsed(const MCSymbol &Symbol) {
|
||||
|
||||
void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
|
||||
|
||||
RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
|
||||
|
||||
RecordStreamer::const_iterator RecordStreamer::begin() {
|
||||
return Symbols.begin();
|
||||
}
|
||||
|
||||
RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
|
||||
|
||||
RecordStreamer::RecordStreamer(MCContext &Context) : MCStreamer(Context) {}
|
||||
|
||||
void RecordStreamer::EmitInstruction(const MCInst &Inst,
|
||||
const MCSubtargetInfo &STI, bool) {
|
||||
MCStreamer::EmitInstruction(Inst, STI);
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
//===-- RecordStreamer.h - Record asm defined and used symbols ---*- C++ -*===//
|
||||
//===- RecordStreamer.h - Record asm defined and used symbols ---*- C++ -*-===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
@ -10,9 +10,16 @@
|
||||
#ifndef LLVM_LIB_OBJECT_RECORDSTREAMER_H
|
||||
#define LLVM_LIB_OBJECT_RECORDSTREAMER_H
|
||||
|
||||
#include "llvm/ADT/DenseMap.h"
|
||||
#include "llvm/ADT/StringMap.h"
|
||||
#include "llvm/MC/MCDirectives.h"
|
||||
#include "llvm/MC/MCStreamer.h"
|
||||
#include "llvm/MC/MCSymbol.h"
|
||||
#include "llvm/Support/SMLoc.h"
|
||||
#include <vector>
|
||||
|
||||
namespace llvm {
|
||||
|
||||
class RecordStreamer : public MCStreamer {
|
||||
public:
|
||||
enum State { NeverSeen, Global, Defined, DefinedGlobal, DefinedWeak, Used,
|
||||
@ -24,16 +31,19 @@ private:
|
||||
// their symbol binding after parsing complete. This maps from each
|
||||
// aliasee to its list of aliases.
|
||||
DenseMap<const MCSymbol *, std::vector<MCSymbol *>> SymverAliasMap;
|
||||
|
||||
void markDefined(const MCSymbol &Symbol);
|
||||
void markGlobal(const MCSymbol &Symbol, MCSymbolAttr Attribute);
|
||||
void markUsed(const MCSymbol &Symbol);
|
||||
void visitUsedSymbol(const MCSymbol &Sym) override;
|
||||
|
||||
public:
|
||||
typedef StringMap<State>::const_iterator const_iterator;
|
||||
RecordStreamer(MCContext &Context);
|
||||
|
||||
using const_iterator = StringMap<State>::const_iterator;
|
||||
|
||||
const_iterator begin();
|
||||
const_iterator end();
|
||||
RecordStreamer(MCContext &Context);
|
||||
void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI,
|
||||
bool) override;
|
||||
void EmitLabel(MCSymbol *Symbol, SMLoc Loc = SMLoc()) override;
|
||||
@ -50,6 +60,7 @@ public:
|
||||
DenseMap<const MCSymbol *, std::vector<MCSymbol *>> &symverAliases() {
|
||||
return SymverAliasMap;
|
||||
}
|
||||
|
||||
/// Get the state recorded for the given symbol.
|
||||
State getSymbolState(const MCSymbol *Sym) {
|
||||
auto SI = Symbols.find(Sym->getName());
|
||||
@ -58,5 +69,7 @@ public:
|
||||
return SI->second;
|
||||
}
|
||||
};
|
||||
}
|
||||
#endif
|
||||
|
||||
} // end namespace llvm
|
||||
|
||||
#endif // LLVM_LIB_OBJECT_RECORDSTREAMER_H
|
||||
|
||||
Loading…
Reference in New Issue
Block a user