This adds the LinkingContext parameter to the ELFReader. Previously the flags in
that were needed in the Context was passed to the ELFReader, this made it very
hard to access data structures in the LinkingContext when reading an ELF file.
This change makes the ELFReader more flexible so that required parameters can be
grabbed directly from the LinkingContext.
Future patches make use of the changes.
There is no change in functionality though.
llvm-svn: 228905
void addSupportCOFFObjects(PECOFFLinkingContext &);
void addSupportCOFFImportLibraries(PECOFFLinkingContext &);
void addSupportMachOObjects(MachOLinkingContext &);
- void addSupportELFObjects(bool atomizeStrings, TargetHandlerBase *handler);
- void addSupportELFDynamicSharedObjects(bool useShlibUndefines,
- TargetHandlerBase *handler);
+ void addSupportELFObjects(ELFLinkingContext &);
+ void addSupportELFDynamicSharedObjects(ELFLinkingContext &);
/// To convert between kind values and names, the registry walks the list
/// of registered kind tables. Each table is a zero terminated array of
virtual ~TargetHandlerBase() {}
virtual void registerRelocationNames(Registry &) = 0;
- virtual std::unique_ptr<Reader> getObjReader(bool) = 0;
+ virtual std::unique_ptr<Reader> getObjReader() = 0;
- virtual std::unique_ptr<Reader> getDSOReader(bool) = 0;
+ virtual std::unique_ptr<Reader> getDSOReader() = 0;
virtual std::unique_ptr<Writer> getWriter() = 0;
};
}
// Register possible input file parsers.
- ctx->registry().addSupportELFObjects(
- ctx->mergeCommonStrings(),
- ctx->targetHandler());
+ ctx->registry().addSupportELFObjects(*ctx);
ctx->registry().addSupportArchives(ctx->logInputFiles());
ctx->registry().addSupportYamlFiles();
ctx->registry().addSupportNativeObjects();
if (ctx->allowLinkWithDynamicLibraries())
- ctx->registry().addSupportELFDynamicSharedObjects(
- ctx->useShlibUndefines(), ctx->targetHandler());
+ ctx->registry().addSupportELFDynamicSharedObjects(*ctx);
std::stack<int> groupStack;
int numfiles = 0;
template <class ELFT> class AArch64ELFFile : public ELFFile<ELFT> {
public:
- AArch64ELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ AArch64ELFFile(std::unique_ptr<MemoryBuffer> mb, AArch64LinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<AArch64ELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, AArch64LinkingContext &ctx) {
return std::unique_ptr<AArch64ELFFile<ELFT>>(
- new AArch64ELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new AArch64ELFFile<ELFT>(std::move(mb), ctx));
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::AArch64DynamicFile<ELFT>::create(std::move(mb),
- useUndefines);
+ AArch64LinkingContext &ctx) {
+ return lld::elf::AArch64DynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::AArch64ELFFile<ELFT>::create(std::move(mb),
- atomizeStrings);
+ AArch64LinkingContext &ctx) {
+ return lld::elf::AArch64ELFFile<ELFT>::create(std::move(mb), ctx);
}
};
class AArch64ELFObjectReader
- : public ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits> {
+ : public ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits,
+ AArch64LinkingContext> {
public:
- AArch64ELFObjectReader(bool atomizeStrings)
- : ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits>(
- atomizeStrings, llvm::ELF::EM_AARCH64) {}
+ AArch64ELFObjectReader(AArch64LinkingContext &ctx)
+ : ELFObjectReader<AArch64ELFType, AArch64ELFFileCreateELFTraits,
+ AArch64LinkingContext>(ctx, llvm::ELF::EM_AARCH64) {}
};
class AArch64ELFDSOReader
- : public ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits> {
+ : public ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits,
+ AArch64LinkingContext> {
public:
- AArch64ELFDSOReader(bool useUndefines)
- : ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits>(
- useUndefines, llvm::ELF::EM_AARCH64) {}
+ AArch64ELFDSOReader(AArch64LinkingContext &ctx)
+ : ELFDSOReader<AArch64ELFType, AArch64DynamicFileCreateELFTraits,
+ AArch64LinkingContext>(ctx, llvm::ELF::EM_AARCH64) {}
};
} // namespace elf
return *(_AArch64RelocationHandler.get());
}
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(new AArch64ELFObjectReader(atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(new AArch64ELFObjectReader(_context));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(new AArch64ELFDSOReader(useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(new AArch64ELFDSOReader(_context));
}
std::unique_ptr<Writer> getWriter() override;
template <class ELFT> class ARMELFFile : public ELFFile<ELFT> {
public:
- ARMELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ ARMELFFile(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<ARMELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, ARMLinkingContext &ctx) {
return std::unique_ptr<ARMELFFile<ELFT>>(
- new ARMELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new ARMELFFile<ELFT>(std::move(mb), ctx));
}
private:
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::ARMDynamicFile<ELFT>::create(std::move(mb), useUndefines);
+ ARMLinkingContext &ctx) {
+ return lld::elf::ARMDynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::ARMELFFile<ELFT>::create(std::move(mb), atomizeStrings);
+ ARMLinkingContext &ctx) {
+ return lld::elf::ARMELFFile<ELFT>::create(std::move(mb), ctx);
}
};
class ARMELFObjectReader
- : public ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits> {
+ : public ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits,
+ ARMLinkingContext> {
public:
- ARMELFObjectReader(bool atomizeStrings)
- : ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits>(
- atomizeStrings, llvm::ELF::EM_ARM) {}
+ ARMELFObjectReader(ARMLinkingContext &ctx)
+ : ELFObjectReader<ARMELFType, ARMELFFileCreateELFTraits,
+ ARMLinkingContext>(ctx, llvm::ELF::EM_ARM) {}
};
class ARMELFDSOReader
- : public ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits> {
+ : public ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits,
+ ARMLinkingContext> {
public:
- ARMELFDSOReader(bool useUndefines)
- : ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits>(
- useUndefines, llvm::ELF::EM_ARM) {}
+ ARMELFDSOReader(ARMLinkingContext &ctx)
+ : ELFDSOReader<ARMELFType, ARMDynamicFileCreateELFTraits,
+ ARMLinkingContext>(ctx, llvm::ELF::EM_ARM) {}
};
} // namespace elf
return *(_armRelocationHandler.get());
}
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(new ARMELFObjectReader(atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(new ARMELFObjectReader(_context));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(new ARMELFDSOReader(useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(new ARMELFDSOReader(_context));
}
std::unique_ptr<Writer> getWriter() override;
public:
const TargetRelocationHandler &getRelocationHandler() const = 0;
- virtual std::unique_ptr<Reader> getObjReader(bool atomizeStrings) = 0;
+ virtual std::unique_ptr<Reader> getObjReader() = 0;
- virtual std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) = 0;
+ virtual std::unique_ptr<Reader> getDSOReader() = 0;
virtual std::unique_ptr<Writer> getWriter() = 0;
};
template <class ELFT> class DynamicFile : public SharedLibraryFile {
public:
static ErrorOr<std::unique_ptr<DynamicFile>>
- create(std::unique_ptr<llvm::MemoryBuffer> mb, bool useShlibUndefines);
+ create(std::unique_ptr<llvm::MemoryBuffer> mb, ELFLinkingContext &ctx);
const SharedLibraryAtom *exports(StringRef name,
bool dataSymbolOnly) const override {
}
private:
- DynamicFile(std::unique_ptr<MemoryBuffer> mb, bool useShlibUndefines)
- : SharedLibraryFile(mb->getBufferIdentifier()),
- _mb(std::move(mb)), _useShlibUndefines(useShlibUndefines) {}
+ DynamicFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
+ : SharedLibraryFile(mb->getBufferIdentifier()), _mb(std::move(mb)),
+ _ctx(ctx), _useShlibUndefines(ctx.useShlibUndefines()) {}
mutable llvm::BumpPtrAllocator _alloc;
std::unique_ptr<llvm::object::ELFFile<ELFT>> _objFile;
};
std::unique_ptr<MemoryBuffer> _mb;
+ ELFLinkingContext &_ctx;
bool _useShlibUndefines;
mutable std::unordered_map<StringRef, SymAtomPair> _nameToSym;
};
template <class ELFT>
ErrorOr<std::unique_ptr<DynamicFile<ELFT>>>
DynamicFile<ELFT>::create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useShlibUndefines) {
- return std::unique_ptr<DynamicFile>(
- new DynamicFile(std::move(mb), useShlibUndefines));
+ ELFLinkingContext &ctx) {
+ return std::unique_ptr<DynamicFile>(new DynamicFile(std::move(mb), ctx));
}
} // end namespace elf
template<class ELFT>
class DynamicLibraryWriter : public OutputELFWriter<ELFT> {
public:
- DynamicLibraryWriter(const ELFLinkingContext &context,
- TargetLayout<ELFT> &layout)
+ DynamicLibraryWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(context, layout),
_runtimeFile(new CRuntimeFile<ELFT>(context)) {}
typedef typename MergedSectionMapT::iterator MergedSectionMapIterT;
public:
- ELFFile(StringRef name)
- : File(name, kindObject), _ordinal(0), _doStringsMerge(false) {
+ ELFFile(StringRef name, ELFLinkingContext &ctx)
+ : File(name, kindObject), _ordinal(0),
+ _doStringsMerge(ctx.mergeCommonStrings()), _ctx(ctx) {
setLastError(std::error_code());
}
- ELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings = false)
+ ELFFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
: File(mb->getBufferIdentifier(), kindObject), _mb(std::move(mb)),
- _ordinal(0), _doStringsMerge(atomizeStrings) {}
+ _ordinal(0), _doStringsMerge(ctx.mergeCommonStrings()), _ctx(ctx) {}
static ErrorOr<std::unique_ptr<ELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings);
+ create(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx);
virtual Reference::KindArch kindArch();
/// \brief the cached options relevant while reading the ELF File
bool _doStringsMerge;
+
+ /// \brief The LinkingContext.
+ ELFLinkingContext &_ctx;
};
/// \brief All atoms are owned by a File. To add linker specific atoms
template <class ELFT> class CRuntimeFile : public ELFFile<ELFT> {
public:
typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
- CRuntimeFile(const ELFLinkingContext &context, StringRef name = "C runtime")
- : ELFFile<ELFT>(name) {}
+ CRuntimeFile(ELFLinkingContext &context, StringRef name = "C runtime")
+ : ELFFile<ELFT>(name, context) {}
/// \brief add a global absolute atom
virtual Atom *addAbsoluteAtom(StringRef symbolName) {
template <class ELFT>
ErrorOr<std::unique_ptr<ELFFile<ELFT>>>
-ELFFile<ELFT>::create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
- std::unique_ptr<ELFFile<ELFT>> file(
- new ELFFile<ELFT>(std::move(mb), atomizeStrings));
+ELFFile<ELFT>::create(std::unique_ptr<MemoryBuffer> mb,
+ ELFLinkingContext &ctx) {
+ std::unique_ptr<ELFFile<ELFT>> file(new ELFFile<ELFT>(std::move(mb), ctx));
return std::move(file);
}
namespace lld {
namespace elf {
-template <typename ELFT, typename ELFTraitsT>
+template <typename ELFT, typename ELFTraitsT, typename ContextT>
class ELFObjectReader : public Reader {
public:
typedef llvm::object::Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
- ELFObjectReader(bool atomizeStrings, uint64_t machine)
- : _atomizeStrings(atomizeStrings), _machine(machine) {}
+ ELFObjectReader(ContextT &ctx, uint64_t machine)
+ : _ctx(ctx), _machine(machine) {}
bool canParse(file_magic magic, StringRef,
const MemoryBuffer &buf) const override {
1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
auto f =
createELF<ELFTraitsT>(llvm::object::getElfArchType(mb->getBuffer()),
- maxAlignment, std::move(mb), _atomizeStrings);
+ maxAlignment, std::move(mb), _ctx);
if (std::error_code ec = f.getError())
return ec;
result.push_back(std::move(*f));
}
protected:
- bool _atomizeStrings;
+ ContextT &_ctx;
uint64_t _machine;
};
-template <typename ELFT, typename ELFTraitsT>
+template <typename ELFT, typename ELFTraitsT, typename ContextT>
class ELFDSOReader : public Reader {
public:
typedef llvm::object::Elf_Ehdr_Impl<ELFT> Elf_Ehdr;
- ELFDSOReader(bool useUndefines, uint64_t machine)
- : _useUndefines(useUndefines), _machine(machine) {}
+ ELFDSOReader(ContextT &ctx, uint64_t machine)
+ : _ctx(ctx), _machine(machine) {}
bool canParse(file_magic magic, StringRef,
const MemoryBuffer &buf) const override {
1ULL << llvm::countTrailingZeros(uintptr_t(mb->getBufferStart()));
auto f =
createELF<ELFTraitsT>(llvm::object::getElfArchType(mb->getBuffer()),
- maxAlignment, std::move(mb), _useUndefines);
+ maxAlignment, std::move(mb), _ctx);
if (std::error_code ec = f.getError())
return ec;
result.push_back(std::move(*f));
}
protected:
- bool _useUndefines;
+ ContextT &_ctx;
uint64_t _machine;
};
template<class ELFT>
class ExecutableWriter : public OutputELFWriter<ELFT> {
public:
- ExecutableWriter(const ELFLinkingContext &context, TargetLayout<ELFT> &layout)
+ ExecutableWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(context, layout),
_runtimeFile(new CRuntimeFile<ELFT>(context)) {}
typedef llvm::object::Elf_Shdr_Impl<ELFT> Elf_Shdr;
public:
- HexagonELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ HexagonELFFile(std::unique_ptr<MemoryBuffer> mb, HexagonLinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<HexagonELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, HexagonLinkingContext &ctx) {
return std::unique_ptr<HexagonELFFile<ELFT>>(
- new HexagonELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new HexagonELFFile<ELFT>(std::move(mb), ctx));
}
bool isCommonSymbol(const Elf_Sym *symbol) const override {
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::HexagonDynamicFile<ELFT>::create(std::move(mb),
- useUndefines);
+ HexagonLinkingContext &ctx) {
+ return lld::elf::HexagonDynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::HexagonELFFile<ELFT>::create(std::move(mb),
- atomizeStrings);
+ HexagonLinkingContext &ctx) {
+ return lld::elf::HexagonELFFile<ELFT>::create(std::move(mb), ctx);
}
};
class HexagonELFObjectReader
- : public ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits> {
+ : public ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits,
+ HexagonLinkingContext> {
public:
- HexagonELFObjectReader(bool atomizeStrings)
- : ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits>(
- atomizeStrings, llvm::ELF::EM_HEXAGON) {}
+ HexagonELFObjectReader(HexagonLinkingContext &ctx)
+ : ELFObjectReader<HexagonELFType, HexagonELFFileCreateELFTraits,
+ HexagonLinkingContext>(ctx, llvm::ELF::EM_HEXAGON) {}
};
class HexagonELFDSOReader
- : public ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits> {
+ : public ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits,
+ HexagonLinkingContext> {
public:
- HexagonELFDSOReader(bool useUndefines)
- : ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits>(
- useUndefines, llvm::ELF::EM_HEXAGON) {}
+ HexagonELFDSOReader(HexagonLinkingContext &ctx)
+ : ELFDSOReader<HexagonELFType, HexagonDynamicFileCreateELFTraits,
+ HexagonLinkingContext>(ctx, llvm::ELF::EM_HEXAGON) {}
};
} // namespace elf
template <class HexagonELFType> class HexagonRuntimeFile
: public CRuntimeFile<HexagonELFType> {
public:
- HexagonRuntimeFile(const HexagonLinkingContext &context)
+ HexagonRuntimeFile(HexagonLinkingContext &context)
: CRuntimeFile<HexagonELFType>(context, "Hexagon runtime file") {}
};
} // elf
return *(_hexagonTargetLayout.get());
}
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(new HexagonELFObjectReader(atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(
+ new HexagonELFObjectReader(_hexagonLinkingContext));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(new HexagonELFDSOReader(useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(
+ new HexagonELFDSOReader(_hexagonLinkingContext));
}
std::unique_ptr<Writer> getWriter() override;
template <class ELFT> class MipsELFFile : public ELFFile<ELFT> {
public:
- MipsELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ MipsELFFile(std::unique_ptr<MemoryBuffer> mb, MipsLinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<MipsELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, MipsLinkingContext &ctx) {
return std::unique_ptr<MipsELFFile<ELFT>>(
- new MipsELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new MipsELFFile<ELFT>(std::move(mb), ctx));
}
bool isPIC() const {
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::MipsELFFile<ELFT>::create(std::move(mb), atomizeStrings);
+ MipsLinkingContext &ctx) {
+ return lld::elf::MipsELFFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::MipsDynamicFile<ELFT>::create(std::move(mb), useUndefines);
+ MipsLinkingContext &ctx) {
+ return lld::elf::MipsDynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
class MipsELFObjectReader
- : public ELFObjectReader<ELFT, MipsELFFileCreateTraits> {
- typedef ELFObjectReader<ELFT, MipsELFFileCreateTraits> BaseReaderType;
+ : public ELFObjectReader<ELFT, MipsELFFileCreateTraits,
+ MipsLinkingContext> {
+ typedef ELFObjectReader<ELFT, MipsELFFileCreateTraits, MipsLinkingContext>
+ BaseReaderType;
public:
- MipsELFObjectReader(MipsLinkingContext &ctx, bool atomizeStrings)
- : BaseReaderType(atomizeStrings, llvm::ELF::EM_MIPS),
+ MipsELFObjectReader(MipsLinkingContext &ctx)
+ : BaseReaderType(ctx, llvm::ELF::EM_MIPS),
_flagMerger(ctx.getELFFlagsMerger()) {}
std::error_code
template <class ELFT>
class MipsELFDSOReader
- : public ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits> {
- typedef ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits> BaseReaderType;
+ : public ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits,
+ MipsLinkingContext> {
+ typedef ELFDSOReader<ELFT, MipsDynamicFileCreateELFTraits, MipsLinkingContext>
+ BaseReaderType;
public:
- MipsELFDSOReader(MipsLinkingContext &ctx, bool useUndefines)
- : BaseReaderType(useUndefines, llvm::ELF::EM_MIPS),
+ MipsELFDSOReader(MipsLinkingContext &ctx)
+ : BaseReaderType(ctx, llvm::ELF::EM_MIPS),
_flagMerger(ctx.getELFFlagsMerger()) {}
std::error_code
template <class ELFType>
class MipsRuntimeFile final : public CRuntimeFile<ELFType> {
public:
- MipsRuntimeFile(const MipsLinkingContext &ctx)
+ MipsRuntimeFile(MipsLinkingContext &ctx)
: CRuntimeFile<ELFType>(ctx, "Mips runtime file") {}
};
MipsTargetLayout<ELFT> &getTargetLayout() override { return *_targetLayout; }
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(
- new MipsELFObjectReader<ELFT>(_ctx, atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(new MipsELFObjectReader<ELFT>(_ctx));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(
- new MipsELFDSOReader<ELFT>(_ctx, useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(new MipsELFDSOReader<ELFT>(_ctx));
}
const TargetRelocationHandler &getRelocationHandler() const override {
// architectures to be pulled into the linker. If we want to support making a
// linker that only supports one ELF architecture, we'd need to change this
// to have a different registration method for each architecture.
-void Registry::addSupportELFObjects(bool atomizeStrings,
- TargetHandlerBase *handler) {
+void Registry::addSupportELFObjects(ELFLinkingContext &ctx) {
// Tell registry about the ELF object file parser.
- add(std::move(handler->getObjReader(atomizeStrings)));
+ add(std::move(ctx.targetHandler()->getObjReader()));
// Tell registry about the relocation name to number mapping for this arch.
- handler->registerRelocationNames(*this);
+ ctx.targetHandler()->registerRelocationNames(*this);
}
-void Registry::addSupportELFDynamicSharedObjects(bool useShlibUndefines,
- TargetHandlerBase *handler) {
+void Registry::addSupportELFDynamicSharedObjects(ELFLinkingContext &ctx) {
// Tell registry about the ELF dynamic shared library file parser.
- add(handler->getDSOReader(useShlibUndefines));
+ add(ctx.targetHandler()->getDSOReader());
}
} // end namespace lld
virtual const TargetRelocationHandler &getRelocationHandler() const = 0;
/// How does the target deal with reading input files.
- virtual std::unique_ptr<Reader> getObjReader(bool) = 0;
+ virtual std::unique_ptr<Reader> getObjReader() = 0;
/// How does the target deal with reading dynamic libraries.
- virtual std::unique_ptr<Reader> getDSOReader(bool) = 0;
+ virtual std::unique_ptr<Reader> getDSOReader() = 0;
/// How does the target deal with writing ELF output.
virtual std::unique_ptr<Writer> getWriter() = 0;
template <class ELFT> class X86ELFFile : public ELFFile<ELFT> {
public:
- X86ELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ X86ELFFile(std::unique_ptr<MemoryBuffer> mb, X86LinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<X86ELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, X86LinkingContext &ctx) {
return std::unique_ptr<X86ELFFile<ELFT>>(
- new X86ELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new X86ELFFile<ELFT>(std::move(mb), ctx));
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::X86DynamicFile<ELFT>::create(std::move(mb), useUndefines);
+ X86LinkingContext &ctx) {
+ return lld::elf::X86DynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::X86ELFFile<ELFT>::create(std::move(mb), atomizeStrings);
+ X86LinkingContext &ctx) {
+ return lld::elf::X86ELFFile<ELFT>::create(std::move(mb), ctx);
}
};
class X86ELFObjectReader
- : public ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits> {
+ : public ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits,
+ X86LinkingContext> {
public:
- X86ELFObjectReader(bool atomizeStrings)
- : ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits>(
- atomizeStrings, llvm::ELF::EM_386) {}
+ X86ELFObjectReader(X86LinkingContext &ctx)
+ : ELFObjectReader<X86ELFType, X86ELFFileCreateELFTraits,
+ X86LinkingContext>(ctx, llvm::ELF::EM_386) {}
};
class X86ELFDSOReader
- : public ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits> {
+ : public ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits,
+ X86LinkingContext> {
public:
- X86ELFDSOReader(bool useUndefines)
- : ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits>(
- useUndefines, llvm::ELF::EM_386) {}
+ X86ELFDSOReader(X86LinkingContext &ctx)
+ : ELFDSOReader<X86ELFType, X86DynamicFileCreateELFTraits,
+ X86LinkingContext>(ctx, llvm::ELF::EM_386) {}
};
} // namespace elf
return *(_x86RelocationHandler.get());
}
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(new X86ELFObjectReader(atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(new X86ELFObjectReader(_x86LinkingContext));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(new X86ELFDSOReader(useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(new X86ELFDSOReader(_x86LinkingContext));
}
std::unique_ptr<Writer> getWriter() override;
template <class ELFT> class X86_64ELFFile : public ELFFile<ELFT> {
public:
- X86_64ELFFile(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings)
- : ELFFile<ELFT>(std::move(mb), atomizeStrings) {}
+ X86_64ELFFile(std::unique_ptr<MemoryBuffer> mb, X86_64LinkingContext &ctx)
+ : ELFFile<ELFT>(std::move(mb), ctx) {}
static ErrorOr<std::unique_ptr<X86_64ELFFile>>
- create(std::unique_ptr<MemoryBuffer> mb, bool atomizeStrings) {
+ create(std::unique_ptr<MemoryBuffer> mb, X86_64LinkingContext &ctx) {
return std::unique_ptr<X86_64ELFFile<ELFT>>(
- new X86_64ELFFile<ELFT>(std::move(mb), atomizeStrings));
+ new X86_64ELFFile<ELFT>(std::move(mb), ctx));
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool useUndefines) {
- return lld::elf::X86_64DynamicFile<ELFT>::create(std::move(mb),
- useUndefines);
+ X86_64LinkingContext &ctx) {
+ return lld::elf::X86_64DynamicFile<ELFT>::create(std::move(mb), ctx);
}
};
template <class ELFT>
static result_type create(std::unique_ptr<llvm::MemoryBuffer> mb,
- bool atomizeStrings) {
- return lld::elf::X86_64ELFFile<ELFT>::create(std::move(mb), atomizeStrings);
+ X86_64LinkingContext &ctx) {
+ return lld::elf::X86_64ELFFile<ELFT>::create(std::move(mb), ctx);
}
};
class X86_64ELFObjectReader
- : public ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits> {
+ : public ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits,
+ X86_64LinkingContext> {
public:
- X86_64ELFObjectReader(bool atomizeStrings)
- : ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits>(
- atomizeStrings, llvm::ELF::EM_X86_64) {}
+ X86_64ELFObjectReader(X86_64LinkingContext &ctx)
+ : ELFObjectReader<X86_64ELFType, X86_64ELFFileCreateELFTraits,
+ X86_64LinkingContext>(ctx, llvm::ELF::EM_X86_64) {}
};
class X86_64ELFDSOReader
- : public ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits> {
+ : public ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits,
+ X86_64LinkingContext> {
public:
- X86_64ELFDSOReader(bool useUndefines)
- : ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits>(
- useUndefines, llvm::ELF::EM_X86_64) {}
+ X86_64ELFDSOReader(X86_64LinkingContext &ctx)
+ : ELFDSOReader<X86_64ELFType, X86_64DynamicFileCreateELFTraits,
+ X86_64LinkingContext>(ctx, llvm::ELF::EM_X86_64) {}
};
} // namespace elf
return *(_x86_64RelocationHandler.get());
}
- std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
- return std::unique_ptr<Reader>(new X86_64ELFObjectReader(atomizeStrings));
+ std::unique_ptr<Reader> getObjReader() override {
+ return std::unique_ptr<Reader>(new X86_64ELFObjectReader(_context));
}
- std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
- return std::unique_ptr<Reader>(new X86_64ELFDSOReader(useShlibUndefines));
+ std::unique_ptr<Reader> getDSOReader() override {
+ return std::unique_ptr<Reader>(new X86_64ELFDSOReader(_context));
}
std::unique_ptr<Writer> getWriter() override;
projects / platform / upstream / llvm.git / commitdiff