That reduce class dependencies and simplify the code a bit.
No functional changes.
llvm-svn: 226255
class MipsDynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
public:
MipsDynamicLibraryWriter(MipsLinkingContext &ctx,
- MipsTargetLayout<ELFT> &layout,
- MipsELFFlagsMerger &elfFlagsMerger);
+ MipsTargetLayout<ELFT> &layout);
protected:
// Add any runtime files and their atoms to the output
template <class ELFT>
MipsDynamicLibraryWriter<ELFT>::MipsDynamicLibraryWriter(
- MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout,
- MipsELFFlagsMerger &elfFlagsMerger)
- : DynamicLibraryWriter<ELFT>(ctx, layout),
- _writeHelper(ctx, layout, elfFlagsMerger), _mipsContext(ctx),
- _mipsTargetLayout(layout) {}
+ MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout)
+ : DynamicLibraryWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
+ _mipsContext(ctx), _mipsTargetLayout(layout) {}
template <class ELFT>
bool MipsDynamicLibraryWriter<ELFT>::createImplicitFiles(
#include "ELFReader.h"
#include "MipsELFFile.h"
#include "MipsELFFlagsMerger.h"
+#include "MipsLinkingContext.h"
namespace lld {
namespace elf {
BaseReaderType;
public:
- MipsELFObjectReader(MipsELFFlagsMerger &flagMerger, bool atomizeStrings)
+ MipsELFObjectReader(MipsLinkingContext &ctx, bool atomizeStrings)
: BaseReaderType(atomizeStrings, llvm::ELF::EM_MIPS),
- _flagMerger(flagMerger) {}
+ _flagMerger(ctx.getELFFlagsMerger()) {}
std::error_code
loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry ®istry,
BaseReaderType;
public:
- MipsELFDSOReader(MipsELFFlagsMerger &flagMerger, bool useUndefines)
+ MipsELFDSOReader(MipsLinkingContext &ctx, bool useUndefines)
: BaseReaderType(useUndefines, llvm::ELF::EM_MIPS),
- _flagMerger(flagMerger) {}
+ _flagMerger(ctx.getELFFlagsMerger()) {}
std::error_code
loadFile(std::unique_ptr<MemoryBuffer> mb, const Registry ®istry,
#ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
#define LLD_READER_WRITER_ELF_MIPS_MIPS_ELF_WRITERS_H
-#include "MipsELFFlagsMerger.h"
#include "MipsLinkingContext.h"
#include "OutputELFWriter.h"
template <typename ELFT> class MipsELFWriter {
public:
- MipsELFWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout,
- MipsELFFlagsMerger &elfFlagsMerger)
- : _ctx(ctx), _targetLayout(targetLayout),
- _elfFlagsMerger(elfFlagsMerger) {}
+ MipsELFWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &targetLayout)
+ : _ctx(ctx), _targetLayout(targetLayout) {}
void setELFHeader(ELFHeader<ELFT> &elfHeader) {
elfHeader.e_version(1);
else
elfHeader.e_ident(llvm::ELF::EI_ABIVERSION, 0);
- elfHeader.e_flags(_elfFlagsMerger.getMergedELFFlags());
+ elfHeader.e_flags(_ctx.getMergedELFFlags());
}
void finalizeMipsRuntimeAtomValues() {
private:
MipsLinkingContext &_ctx;
MipsTargetLayout<ELFT> &_targetLayout;
- MipsELFFlagsMerger &_elfFlagsMerger;
void setAtomValue(StringRef name, uint64_t value) {
auto atom = _targetLayout.findAbsoluteAtom(name);
template <class ELFT>
class MipsExecutableWriter : public ExecutableWriter<ELFT> {
public:
- MipsExecutableWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout,
- MipsELFFlagsMerger &elfFlagsMerger);
+ MipsExecutableWriter(MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout);
protected:
void buildDynamicSymbolTable(const File &file) override;
};
template <class ELFT>
-MipsExecutableWriter<ELFT>::MipsExecutableWriter(
- MipsLinkingContext &ctx, MipsTargetLayout<ELFT> &layout,
- MipsELFFlagsMerger &elfFlagsMerger)
- : ExecutableWriter<ELFT>(ctx, layout),
- _writeHelper(ctx, layout, elfFlagsMerger), _mipsContext(ctx),
- _mipsTargetLayout(layout) {}
+MipsExecutableWriter<ELFT>::MipsExecutableWriter(MipsLinkingContext &ctx,
+ MipsTargetLayout<ELFT> &layout)
+ : ExecutableWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
+ _mipsContext(ctx), _mipsTargetLayout(layout) {}
template <class ELFT>
std::error_code MipsExecutableWriter<ELFT>::setELFHeader() {
new MipsTargetHandler(*this))) {}
uint32_t MipsLinkingContext::getMergedELFFlags() const {
- const auto &handler = static_cast<MipsTargetHandler &>(
- ELFLinkingContext::getTargetHandler<Mips32ElELFType>());
- return handler.getELFFlagsMerger().getMergedELFFlags();
+ return _flagsMerger.getMergedELFFlags();
+}
+
+MipsELFFlagsMerger &MipsLinkingContext::getELFFlagsMerger() {
+ return _flagsMerger;
}
uint64_t MipsLinkingContext::getBaseAddress() const {
#ifndef LLD_READER_WRITER_ELF_MIPS_MIPS_LINKING_CONTEXT_H
#define LLD_READER_WRITER_ELF_MIPS_MIPS_LINKING_CONTEXT_H
+#include "MipsELFFlagsMerger.h"
#include "lld/ReaderWriter/ELFLinkingContext.h"
namespace lld {
MipsLinkingContext(llvm::Triple triple);
uint32_t getMergedELFFlags() const;
+ MipsELFFlagsMerger &getELFFlagsMerger();
// ELFLinkingContext
uint64_t getBaseAddress() const override;
const Reference &r) const override;
bool isCopyRelocation(const Reference &r) const override;
bool isPLTRelocation(const DefinedAtom &, const Reference &r) const override;
+
+private:
+ MipsELFFlagsMerger _flagsMerger;
};
} // elf
std::unique_ptr<Writer> MipsTargetHandler::getWriter() {
switch (_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
- return std::unique_ptr<Writer>(new MipsExecutableWriter<Mips32ElELFType>(
- _ctx, *_targetLayout, _elfFlagsMerger));
+ return std::unique_ptr<Writer>(
+ new MipsExecutableWriter<Mips32ElELFType>(_ctx, *_targetLayout));
case llvm::ELF::ET_DYN:
return std::unique_ptr<Writer>(
- new MipsDynamicLibraryWriter<Mips32ElELFType>(_ctx, *_targetLayout,
- _elfFlagsMerger));
+ new MipsDynamicLibraryWriter<Mips32ElELFType>(_ctx, *_targetLayout));
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:
#define LLD_READER_WRITER_ELF_MIPS_MIPS_TARGET_HANDLER_H
#include "DefaultTargetHandler.h"
-#include "MipsELFFlagsMerger.h"
#include "MipsELFReader.h"
#include "MipsLinkingContext.h"
#include "MipsRelocationHandler.h"
public:
MipsTargetHandler(MipsLinkingContext &ctx);
- const MipsELFFlagsMerger &getELFFlagsMerger() const {
- return _elfFlagsMerger;
- }
-
MipsTargetLayout<Mips32ElELFType> &getTargetLayout() override {
return *_targetLayout;
}
std::unique_ptr<Reader> getObjReader(bool atomizeStrings) override {
return std::unique_ptr<Reader>(
- new MipsELFObjectReader(_elfFlagsMerger, atomizeStrings));
+ new MipsELFObjectReader(_ctx, atomizeStrings));
}
std::unique_ptr<Reader> getDSOReader(bool useShlibUndefines) override {
return std::unique_ptr<Reader>(
- new MipsELFDSOReader(_elfFlagsMerger, useShlibUndefines));
+ new MipsELFDSOReader(_ctx, useShlibUndefines));
}
const MipsTargetRelocationHandler &getRelocationHandler() const override {
private:
static const Registry::KindStrings kindStrings[];
MipsLinkingContext &_ctx;
- MipsELFFlagsMerger _elfFlagsMerger;
std::unique_ptr<MipsRuntimeFile<Mips32ElELFType>> _runtimeFile;
std::unique_ptr<MipsTargetLayout<Mips32ElELFType>> _targetLayout;
std::unique_ptr<MipsTargetRelocationHandler> _relocationHandler;