maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Rename ELFLinkingContext instances "ctx" intead of "context". 

llvm-svn: 233344
This commit is contained in:
Rui Ueyama 2015-03-27 01:36:17 +00:00
parent 12c8f65408
commit c9ee4de6ca
37 changed files with 272 additions and 297 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lld/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
View File

@ -19,7 +19,7 @@ namespace elf {
template <class ELFT>
class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
public:
AArch64DynamicLibraryWriter(AArch64LinkingContext &context,
AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
AArch64TargetLayout<ELFT> &layout);
protected:
@ -42,16 +42,15 @@ private:
};
std::unique_ptr<GOTFile> _gotFile;
AArch64LinkingContext &_context;
AArch64LinkingContext &_ctx;
AArch64TargetLayout<ELFT> &_AArch64Layout;
};
template <class ELFT>
AArch64DynamicLibraryWriter<ELFT>::AArch64DynamicLibraryWriter(
AArch64LinkingContext &context, AArch64TargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(context, layout),
_gotFile(new GOTFile(context)), _context(context),
_AArch64Layout(layout) {}
AArch64LinkingContext &ctx, AArch64TargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
_ctx(ctx), _AArch64Layout(layout) {}
template <class ELFT>
bool AArch64DynamicLibraryWriter<ELFT>::createImplicitFiles(

12
lld/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
View File

@ -18,7 +18,7 @@ namespace elf {
template <class ELFT>
class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
public:
AArch64ExecutableWriter(AArch64LinkingContext &context,
AArch64ExecutableWriter(AArch64LinkingContext &ctx,
AArch64TargetLayout<ELFT> &layout);
protected:
@ -41,22 +41,22 @@ private:
};
std::unique_ptr<GOTFile> _gotFile;
AArch64LinkingContext &_context;
AArch64LinkingContext &_ctx;
AArch64TargetLayout<ELFT> &_AArch64Layout;
};
template <class ELFT>
AArch64ExecutableWriter<ELFT>::AArch64ExecutableWriter(
AArch64LinkingContext &context, AArch64TargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(context, layout), _gotFile(new GOTFile(context)),
_context(context), _AArch64Layout(layout) {}
AArch64LinkingContext &ctx, AArch64TargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
_ctx(ctx), _AArch64Layout(layout) {}
template <class ELFT>
bool AArch64ExecutableWriter<ELFT>::createImplicitFiles(
std::vector<std::unique_ptr<File>> &result) {
ExecutableWriter<ELFT>::createImplicitFiles(result);
_gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
if (_context.isDynamic())
if (_ctx.isDynamic())
_gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
result.push_back(std::move(_gotFile));
return true;

12
lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
View File

@ -16,9 +16,9 @@
using namespace lld;
using namespace elf;
AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &context)
: _context(context),
_AArch64TargetLayout(new AArch64TargetLayout<AArch64ELFType>(context)),
AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &ctx)
: _ctx(ctx),
_AArch64TargetLayout(new AArch64TargetLayout<AArch64ELFType>(ctx)),
_AArch64RelocationHandler(new AArch64TargetRelocationHandler()) {}
void AArch64TargetHandler::registerRelocationNames(Registry &registry) {
@ -27,13 +27,13 @@ void AArch64TargetHandler::registerRelocationNames(Registry &registry) {
}
std::unique_ptr<Writer> AArch64TargetHandler::getWriter() {
switch (this->_context.getOutputELFType()) {
switch (this->_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<AArch64ExecutableWriter<AArch64ELFType>>(
_context, *_AArch64TargetLayout.get());
_ctx, *_AArch64TargetLayout.get());
case llvm::ELF::ET_DYN:
return llvm::make_unique<AArch64DynamicLibraryWriter<AArch64ELFType>>(
_context, *_AArch64TargetLayout.get());
_ctx, *_AArch64TargetLayout.get());
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:

11
lld/lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h
View File

@ -23,13 +23,12 @@ class AArch64LinkingContext;
template <class ELFT> class AArch64TargetLayout : public TargetLayout<ELFT> {
public:
AArch64TargetLayout(AArch64LinkingContext &context)
: TargetLayout<ELFT>(context) {}
AArch64TargetLayout(AArch64LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
};
class AArch64TargetHandler final : public DefaultTargetHandler<AArch64ELFType> {
public:
AArch64TargetHandler(AArch64LinkingContext &context);
AArch64TargetHandler(AArch64LinkingContext &ctx);
AArch64TargetLayout<AArch64ELFType> &getTargetLayout() override {
return *(_AArch64TargetLayout.get());
@ -42,18 +41,18 @@ public:
}
std::unique_ptr<Reader> getObjReader() override {
return std::unique_ptr<Reader>(new AArch64ELFObjectReader(_context));
return std::unique_ptr<Reader>(new AArch64ELFObjectReader(_ctx));
}
std::unique_ptr<Reader> getDSOReader() override {
return std::unique_ptr<Reader>(new AArch64ELFDSOReader(_context));
return std::unique_ptr<Reader>(new AArch64ELFDSOReader(_ctx));
}
std::unique_ptr<Writer> getWriter() override;
private:
static const Registry::KindStrings kindStrings[];
AArch64LinkingContext &_context;
AArch64LinkingContext &_ctx;
std::unique_ptr<AArch64TargetLayout<AArch64ELFType>> _AArch64TargetLayout;
std::unique_ptr<AArch64TargetRelocationHandler> _AArch64RelocationHandler;
};

14
lld/lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
View File

@ -24,8 +24,7 @@ namespace elf {
template <class ELFT>
class ARMExecutableWriter : public ExecutableWriter<ELFT> {
public:
ARMExecutableWriter(ARMLinkingContext &context,
ARMTargetLayout<ELFT> &layout);
ARMExecutableWriter(ARMLinkingContext &ctx, ARMTargetLayout<ELFT> &layout);
protected:
// Add any runtime files and their atoms to the output
@ -47,15 +46,14 @@ protected:
std::error_code setELFHeader() override;
private:
ARMLinkingContext &_context;
ARMLinkingContext &_ctx;
ARMTargetLayout<ELFT> &_armLayout;
};
template <class ELFT>
ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &context,
ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &ctx,
ARMTargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(context, layout), _context(context),
_armLayout(layout) {}
: ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
template <class ELFT>
bool ARMExecutableWriter<ELFT>::createImplicitFiles(
@ -85,7 +83,7 @@ template <class ELFT>
unique_bump_ptr<SymbolTable<ELFT>>
ARMExecutableWriter<ELFT>::createSymbolTable() {
return unique_bump_ptr<SymbolTable<ELFT>>(
new (this->_alloc) ARMSymbolTable<ELFT>(this->_context));
new (this->_alloc) ARMSymbolTable<ELFT>(this->_ctx));
}
template <class ELFT>
@ -105,7 +103,7 @@ std::error_code ARMExecutableWriter<ELFT>::setELFHeader() {
return ec;
// Fixup entry point for Thumb code.
StringRef entryName = _context.entrySymbolName();
StringRef entryName = _ctx.entrySymbolName();
if (const AtomLayout *al = _armLayout.findAtomLayoutByName(entryName)) {
const auto *ea = dyn_cast<DefinedAtom>(al->_atom);
if (ea && ea->codeModel() == DefinedAtom::codeARMThumb)

6
lld/lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
View File

@ -19,15 +19,15 @@ class ARMSymbolTable : public SymbolTable<ELFT> {
public:
typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
ARMSymbolTable(const ELFLinkingContext &context);
ARMSymbolTable(const ELFLinkingContext &ctx);
void addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
int64_t addr) override;
};
template <class ELFT>
ARMSymbolTable<ELFT>::ARMSymbolTable(const ELFLinkingContext &context)
: SymbolTable<ELFT>(context, ".symtab",
ARMSymbolTable<ELFT>::ARMSymbolTable(const ELFLinkingContext &ctx)
: SymbolTable<ELFT>(ctx, ".symtab",
DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE) {}
template <class ELFT>

13
lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
View File

@ -15,11 +15,10 @@
using namespace lld;
using namespace elf;
ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &context)
: _context(context), _armTargetLayout(
new ARMTargetLayout<ARMELFType>(context)),
_armRelocationHandler(new ARMTargetRelocationHandler(
*_armTargetLayout.get())) {}
ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &ctx)
: _ctx(ctx), _armTargetLayout(new ARMTargetLayout<ARMELFType>(ctx)),
_armRelocationHandler(
new ARMTargetRelocationHandler(*_armTargetLayout.get())) {}
void ARMTargetHandler::registerRelocationNames(Registry &registry) {
registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::ARM,
@ -27,10 +26,10 @@ void ARMTargetHandler::registerRelocationNames(Registry &registry) {
}
std::unique_ptr<Writer> ARMTargetHandler::getWriter() {
switch (this->_context.getOutputELFType()) {
switch (this->_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<ARMExecutableWriter<ARMELFType>>(
_context, *_armTargetLayout.get());
_ctx, *_armTargetLayout.get());
default:
llvm_unreachable("unsupported output type");
}

11
lld/lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
View File

@ -27,8 +27,7 @@ class ARMLinkingContext;
template <class ELFT> class ARMTargetLayout : public TargetLayout<ELFT> {
public:
ARMTargetLayout(ARMLinkingContext &context)
: TargetLayout<ELFT>(context) {}
ARMTargetLayout(ARMLinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
uint64_t getTPOffset() {
if (_tpOff.hasValue())
@ -53,7 +52,7 @@ private:
class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
public:
ARMTargetHandler(ARMLinkingContext &context);
ARMTargetHandler(ARMLinkingContext &ctx);
ARMTargetLayout<ARMELFType> &getTargetLayout() override {
return *(_armTargetLayout.get());
@ -66,18 +65,18 @@ public:
}
std::unique_ptr<Reader> getObjReader() override {
return std::unique_ptr<Reader>(new ARMELFObjectReader(_context));
return std::unique_ptr<Reader>(new ARMELFObjectReader(_ctx));
}
std::unique_ptr<Reader> getDSOReader() override {
return std::unique_ptr<Reader>(new ARMELFDSOReader(_context));
return std::unique_ptr<Reader>(new ARMELFDSOReader(_ctx));
}
std::unique_ptr<Writer> getWriter() override;
private:
static const Registry::KindStrings kindStrings[];
ARMLinkingContext &_context;
ARMLinkingContext &_ctx;
std::unique_ptr<ARMTargetLayout<ARMELFType>> _armTargetLayout;
std::unique_ptr<ARMTargetRelocationHandler> _armRelocationHandler;
};

8
lld/lib/ReaderWriter/ELF/Chunk.h
View File

@ -45,9 +45,9 @@ public:
/// \brief the ContentType of the chunk
enum ContentType : uint8_t{ Unknown, Header, Code, Data, Note, TLS };
Chunk(StringRef name, Kind kind, const ELFLinkingContext &context)
: _name(name), _kind(kind), _fsize(0), _msize(0), _alignment(0), _order(0),
_ordinal(1), _start(0), _fileoffset(0), _context(context) {}
Chunk(StringRef name, Kind kind, const ELFLinkingContext &ctx)
: _name(name), _kind(kind), _fsize(0), _msize(0), _alignment(0),
_order(0), _ordinal(1), _start(0), _fileoffset(0), _ctx(ctx) {}
virtual ~Chunk() {}
// The name of the chunk
StringRef name() const { return _name; }
@ -93,7 +93,7 @@ protected:
uint64_t _ordinal;
uint64_t _start;
uint64_t _fileoffset;
const ELFLinkingContext &_context;
const ELFLinkingContext &_ctx;
};
} // end namespace elf

39
lld/lib/ReaderWriter/ELF/DefaultLayout.h
View File

@ -170,8 +170,8 @@ public:
typedef llvm::DenseSet<const Atom *> AtomSetT;
DefaultLayout(ELFLinkingContext &context)
: _context(context), _linkerScriptSema(context.linkerScriptSema()) {}
DefaultLayout(ELFLinkingContext &ctx)
: _ctx(ctx), _linkerScriptSema(ctx.linkerScriptSema()) {}
/// \brief Return the section order for a input section
SectionOrder getSectionOrder(StringRef name, int32_t contentType,
@ -283,7 +283,7 @@ public:
RelocationTable<ELFT> *getDynamicRelocationTable() {
if (!_dynamicRelocationTable) {
_dynamicRelocationTable = std::move(createRelocationTable(
_context.isRelaOutputFormat() ? ".rela.dyn" : ".rel.dyn",
_ctx.isRelaOutputFormat() ? ".rela.dyn" : ".rel.dyn",
ORDER_DYNAMIC_RELOCS));
addSection(_dynamicRelocationTable.get());
}
@ -294,7 +294,7 @@ public:
RelocationTable<ELFT> *getPLTRelocationTable() {
if (!_pltRelocationTable) {
_pltRelocationTable = std::move(createRelocationTable(
_context.isRelaOutputFormat() ? ".rela.plt" : ".rel.plt",
_ctx.isRelaOutputFormat() ? ".rela.plt" : ".rel.plt",
ORDER_DYNAMIC_PLT_RELOCS));
addSection(_pltRelocationTable.get());
}
@ -335,7 +335,7 @@ protected:
virtual unique_bump_ptr<RelocationTable<ELFT>>
createRelocationTable(StringRef name, int32_t order) {
return unique_bump_ptr<RelocationTable<ELFT>>(
new (_allocator) RelocationTable<ELFT>(_context, name, order));
new (_allocator) RelocationTable<ELFT>(_ctx, name, order));
}
private:
@ -358,7 +358,7 @@ protected:
std::vector<lld::AtomLayout *> _absoluteAtoms;
AtomSetT _referencedDynAtoms;
llvm::StringSet<> _copiedDynSymNames;
ELFLinkingContext &_context;
ELFLinkingContext &_ctx;
script::Sema &_linkerScriptSema;
};
@ -570,7 +570,7 @@ template <class ELFT>
AtomSection<ELFT> *DefaultLayout<ELFT>::createSection(
StringRef sectionName, int32_t contentType,
DefinedAtom::ContentPermissions permissions, SectionOrder sectionOrder) {
return new (_allocator) AtomSection<ELFT>(_context, sectionName, contentType,
return new (_allocator) AtomSection<ELFT>(_ctx, sectionName, contentType,
permissions, sectionOrder);
}
@ -617,10 +617,10 @@ DefaultLayout<ELFT>::addAtom(const Atom *atom) {
// Add runtime relocations to the .rela section.
for (const auto &reloc : *definedAtom) {
bool isLocalReloc = true;
if (_context.isDynamicRelocation(*reloc)) {
if (_ctx.isDynamicRelocation(*reloc)) {
getDynamicRelocationTable()->addRelocation(*definedAtom, *reloc);
isLocalReloc = false;
} else if (_context.isPLTRelocation(*reloc)) {
} else if (_ctx.isPLTRelocation(*reloc)) {
getPLTRelocationTable()->addRelocation(*definedAtom, *reloc);
isLocalReloc = false;
}
@ -632,7 +632,7 @@ DefaultLayout<ELFT>::addAtom(const Atom *atom) {
if (isa<UndefinedAtom>(reloc->target()) && isLocalReloc)
continue;
if (_context.isCopyRelocation(*reloc)) {
if (_ctx.isCopyRelocation(*reloc)) {
_copiedDynSymNames.insert(definedAtom->name());
continue;
}
@ -716,7 +716,7 @@ void DefaultLayout<ELFT>::sortOutputSectionByPriority(
template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
ScopedTask task(getDefaultDomain(), "assignSectionsToSegments");
ELFLinkingContext::OutputMagic outputMagic = _context.getOutputMagic();
ELFLinkingContext::OutputMagic outputMagic = _ctx.getOutputMagic();
// sort the sections by their order as defined by the layout
sortInputSections();
@ -752,7 +752,7 @@ template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
int64_t lookupSectionFlag = osi->flags();
if ((!(lookupSectionFlag & llvm::ELF::SHF_WRITE)) &&
(_context.mergeRODataToTextSegment()))
(_ctx.mergeRODataToTextSegment()))
lookupSectionFlag &= ~llvm::ELF::SHF_EXECINSTR;
// Merge string sections into Data segment itself
@ -774,8 +774,8 @@ template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
if (!additionalSegmentInsert.second) {
segment = additionalSegmentInsert.first->second;
} else {
segment = new (_allocator)
Segment<ELFT>(_context, segmentName, segmentType);
segment =
new (_allocator) Segment<ELFT>(_ctx, segmentName, segmentType);
additionalSegmentInsert.first->second = segment;
_segments.push_back(segment);
}
@ -802,7 +802,7 @@ template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
segment = segmentInsert.first->second;
} else {
segment = new (_allocator)
Segment<ELFT>(_context, "PT_LOAD", llvm::ELF::PT_LOAD);
Segment<ELFT>(_ctx, "PT_LOAD", llvm::ELF::PT_LOAD);
segmentInsert.first->second = segment;
_segments.push_back(segment);
}
@ -815,9 +815,8 @@ template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
}
}
}
if (_context.isDynamic() && !_context.isDynamicLibrary()) {
Segment<ELFT> *segment =
new (_allocator) ProgramHeaderSegment<ELFT>(_context);
if (_ctx.isDynamic() && !_ctx.isDynamicLibrary()) {
Segment<ELFT> *segment = new (_allocator) ProgramHeaderSegment<ELFT>(_ctx);
_segments.push_back(segment);
segment->append(_elfHeader);
segment->append(_programHeader);
@ -832,7 +831,7 @@ DefaultLayout<ELFT>::assignVirtualAddress() {
std::sort(_segments.begin(), _segments.end(), Segment<ELFT>::compareSegments);
uint64_t baseAddress = _context.getBaseAddress();
uint64_t baseAddress = _ctx.getBaseAddress();
// HACK: This is a super dirty hack. The elf header and program header are
// not part of a section, but we need them to be loaded at the base address
@ -1039,7 +1038,7 @@ void DefaultLayout<ELFT>::addExtraChunksToSegment(Segment<ELFT> *segment,
_linkerScriptSema.getExprs({archivePath, memberPath, sectionName});
for (auto expr : exprs) {
auto expChunk =
new (this->_allocator) ExpressionChunk<ELFT>(this->_context, expr);
new (this->_allocator) ExpressionChunk<ELFT>(this->_ctx, expr);
segment->append(expChunk);
}
}

6
lld/lib/ReaderWriter/ELF/DynamicLibraryWriter.h
View File

@ -25,9 +25,9 @@ class DynamicLibraryWriter;
template<class ELFT>
class DynamicLibraryWriter : public OutputELFWriter<ELFT> {
public:
DynamicLibraryWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(context, layout),
_runtimeFile(new RuntimeFile<ELFT>(context, "C runtime")) {}
DynamicLibraryWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(ctx, layout),
_runtimeFile(new RuntimeFile<ELFT>(ctx, "C runtime")) {}
protected:
virtual void buildDynamicSymbolTable(const File &file);

4
lld/lib/ReaderWriter/ELF/ELFFile.h
View File

@ -445,8 +445,8 @@ protected:
template <class ELFT> class RuntimeFile : public ELFFile<ELFT> {
public:
typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
RuntimeFile(ELFLinkingContext &context, StringRef name)
: ELFFile<ELFT>(name, context) {}
RuntimeFile(ELFLinkingContext &ctx, StringRef name)
: ELFFile<ELFT>(name, ctx) {}
/// \brief add a global absolute atom
virtual Atom *addAbsoluteAtom(StringRef symbolName) {

24
lld/lib/ReaderWriter/ELF/ExecutableWriter.h
View File

@ -25,9 +25,9 @@ class ExecutableWriter;
template<class ELFT>
class ExecutableWriter : public OutputELFWriter<ELFT> {
public:
ExecutableWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(context, layout),
_runtimeFile(new RuntimeFile<ELFT>(context, "C runtime")) {}
ExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
: OutputELFWriter<ELFT>(ctx, layout),
_runtimeFile(new RuntimeFile<ELFT>(ctx, "C runtime")) {}
protected:
virtual void buildDynamicSymbolTable(const File &file);
@ -56,8 +56,8 @@ void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
if (!da)
continue;
if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
!this->_context.isDynamicallyExportedSymbol(da->name()) &&
!(this->_context.shouldExportDynamic() &&
!this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
!(this->_ctx.shouldExportDynamic() &&
da->scope() == Atom::Scope::scopeGlobal))
continue;
this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
@ -65,7 +65,7 @@ void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
}
// Put weak symbols in the dynamic symbol table.
if (this->_context.isDynamic()) {
if (this->_ctx.isDynamic()) {
for (const UndefinedAtom *a : file.undefined()) {
if (this->_layout.isReferencedByDefinedAtom(a) &&
a->canBeNull() != UndefinedAtom::canBeNullNever)
@ -81,7 +81,7 @@ void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
template<class ELFT>
void ExecutableWriter<ELFT>::addDefaultAtoms() {
OutputELFWriter<ELFT>::addDefaultAtoms();
_runtimeFile->addUndefinedAtom(this->_context.entrySymbolName());
_runtimeFile->addUndefinedAtom(this->_ctx.entrySymbolName());
_runtimeFile->addAbsoluteAtom("__bss_start");
_runtimeFile->addAbsoluteAtom("__bss_end");
_runtimeFile->addAbsoluteAtom("_end");
@ -90,7 +90,7 @@ void ExecutableWriter<ELFT>::addDefaultAtoms() {
_runtimeFile->addAbsoluteAtom("__preinit_array_end");
_runtimeFile->addAbsoluteAtom("__init_array_start");
_runtimeFile->addAbsoluteAtom("__init_array_end");
if (this->_context.isRelaOutputFormat()) {
if (this->_ctx.isRelaOutputFormat()) {
_runtimeFile->addAbsoluteAtom("__rela_iplt_start");
_runtimeFile->addAbsoluteAtom("__rela_iplt_end");
} else {
@ -114,10 +114,10 @@ bool ExecutableWriter<ELFT>::createImplicitFiles(
template <class ELFT> void ExecutableWriter<ELFT>::createDefaultSections() {
OutputELFWriter<ELFT>::createDefaultSections();
if (this->_context.isDynamic()) {
if (this->_ctx.isDynamic()) {
_interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
this->_context, ".interp", DefaultLayout<ELFT>::ORDER_INTERP,
this->_context.getInterpreter()));
this->_ctx, ".interp", DefaultLayout<ELFT>::ORDER_INTERP,
this->_ctx.getInterpreter()));
this->_layout.addSection(_interpSection.get());
}
}
@ -148,7 +148,7 @@ template <class ELFT> void ExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
startEnd("preinit_array", ".preinit_array");
startEnd("init_array", ".init_array");
if (this->_context.isRelaOutputFormat())
if (this->_ctx.isRelaOutputFormat())
startEnd("rela_iplt", ".rela.plt");
else
startEnd("rel_iplt", ".rel.plt");

19
lld/lib/ReaderWriter/ELF/HeaderChunks.h
View File

@ -63,8 +63,8 @@ public:
(ELFT::TargetEndianness == llvm::support::little)
? llvm::ELF::ELFDATA2LSB
: llvm::ELF::ELFDATA2MSB;
_eh.e_type = this->_context.getOutputELFType();
_eh.e_machine = this->_context.getOutputMachine();
_eh.e_type = this->_ctx.getOutputELFType();
_eh.e_machine = this->_ctx.getOutputMachine();
}
private:
@ -72,8 +72,8 @@ private:
};
template <class ELFT>
ELFHeader<ELFT>::ELFHeader(const ELFLinkingContext &context)
: Chunk<ELFT>("elfhdr", Chunk<ELFT>::Kind::ELFHeader, context) {
ELFHeader<ELFT>::ELFHeader(const ELFLinkingContext &ctx)
: Chunk<ELFT>("elfhdr", Chunk<ELFT>::Kind::ELFHeader, ctx) {
this->_alignment = ELFT::Is64Bits ? 8 : 4;
this->_fsize = sizeof(Elf_Ehdr);
this->_msize = sizeof(Elf_Ehdr);
@ -124,8 +124,8 @@ public:
uint64_t _flagsClear;
};
ProgramHeader(const ELFLinkingContext &context)
: Chunk<ELFT>("elfphdr", Chunk<ELFT>::Kind::ProgramHeader, context) {
ProgramHeader(const ELFLinkingContext &ctx)
: Chunk<ELFT>("elfphdr", Chunk<ELFT>::Kind::ProgramHeader, ctx) {
this->_alignment = ELFT::Is64Bits ? 8 : 4;
resetProgramHeaders();
}
@ -197,7 +197,7 @@ private:
template <class ELFT>
bool ProgramHeader<ELFT>::addSegment(Segment<ELFT> *segment) {
bool allocatedNew = false;
ELFLinkingContext::OutputMagic outputMagic = this->_context.getOutputMagic();
ELFLinkingContext::OutputMagic outputMagic = this->_ctx.getOutputMagic();
// For segments that are not a loadable segment, we
// just pick the values directly from the segment as there
// wouldnt be any slices within that
@ -300,9 +300,8 @@ private:
};
template <class ELFT>
SectionHeader<ELFT>::SectionHeader(const ELFLinkingContext &context,
int32_t order)
: Chunk<ELFT>("shdr", Chunk<ELFT>::Kind::SectionHeader, context) {
SectionHeader<ELFT>::SectionHeader(const ELFLinkingContext &ctx, int32_t order)
: Chunk<ELFT>("shdr", Chunk<ELFT>::Kind::SectionHeader, ctx) {
this->_fsize = 0;
this->_alignment = 8;
this->setOrder(order);

12
lld/lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
View File

@ -22,7 +22,7 @@ template <class ELFT>
class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT>,
public HexagonELFWriter<ELFT> {
public:
HexagonDynamicLibraryWriter(HexagonLinkingContext &context,
HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
HexagonTargetLayout<ELFT> &layout);
protected:
@ -43,18 +43,18 @@ private:
_hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
}
HexagonLinkingContext &_hexagonLinkingContext;
HexagonLinkingContext &_ctx;
HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
};
template <class ELFT>
HexagonDynamicLibraryWriter<ELFT>::HexagonDynamicLibraryWriter(
HexagonLinkingContext &context, HexagonTargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(context, layout),
HexagonELFWriter<ELFT>(context, layout), _hexagonLinkingContext(context),
HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(ctx, layout),
HexagonELFWriter<ELFT>(ctx, layout), _ctx(ctx),
_hexagonTargetLayout(layout),
_hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(context)) {}
_hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
template <class ELFT>
bool HexagonDynamicLibraryWriter<ELFT>::createImplicitFiles(

8
lld/lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h
View File

@ -20,9 +20,9 @@ template <class ELFT> class HexagonTargetLayout;
template <typename ELFT> class HexagonELFWriter {
public:
HexagonELFWriter(HexagonLinkingContext &context,
HexagonELFWriter(HexagonLinkingContext &ctx,
HexagonTargetLayout<ELFT> &targetLayout)
: _hexagonLinkingContext(context), _hexagonTargetLayout(targetLayout) {}
: _ctx(ctx), _hexagonTargetLayout(targetLayout) {}
protected:
bool setELFHeader(ELFHeader<ELFT> &elfHeader) {
@ -34,7 +34,7 @@ protected:
}
void finalizeHexagonRuntimeAtomValues() {
if (_hexagonLinkingContext.isDynamic()) {
if (_ctx.isDynamic()) {
auto gotAtomIter =
_hexagonTargetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
auto gotpltSection = _hexagonTargetLayout.findOutputSection(".got.plt");
@ -52,7 +52,7 @@ protected:
}
private:
HexagonLinkingContext &_hexagonLinkingContext;
HexagonLinkingContext &_ctx;
HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
};

4
lld/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h
View File

@ -20,8 +20,8 @@ class HexagonLinkingContext;
template <class HexagonELFType> class HexagonRuntimeFile
: public RuntimeFile<HexagonELFType> {
public:
HexagonRuntimeFile(HexagonLinkingContext &context)
: RuntimeFile<HexagonELFType>(context, "Hexagon runtime file") {}
HexagonRuntimeFile(HexagonLinkingContext &ctx)
: RuntimeFile<HexagonELFType>(ctx, "Hexagon runtime file") {}
};
} // elf
} // lld

15
lld/lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
View File

@ -23,7 +23,7 @@ template <class ELFT>
class HexagonExecutableWriter : public ExecutableWriter<ELFT>,
public HexagonELFWriter<ELFT> {
public:
HexagonExecutableWriter(HexagonLinkingContext &context,
HexagonExecutableWriter(HexagonLinkingContext &ctx,
HexagonTargetLayout<ELFT> &layout);
protected:
@ -41,24 +41,23 @@ protected:
private:
void addDefaultAtoms() {
_hexagonRuntimeFile->addAbsoluteAtom("_SDA_BASE_");
if (this->_context.isDynamic()) {
if (this->_ctx.isDynamic()) {
_hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
_hexagonRuntimeFile->addAbsoluteAtom("_DYNAMIC");
}
}
HexagonLinkingContext &_hexagonLinkingContext;
HexagonLinkingContext &_ctx;
HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
std::unique_ptr<HexagonRuntimeFile<ELFT>> _hexagonRuntimeFile;
};
template <class ELFT>
HexagonExecutableWriter<ELFT>::HexagonExecutableWriter(
HexagonLinkingContext &context, HexagonTargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(context, layout),
HexagonELFWriter<ELFT>(context, layout), _hexagonLinkingContext(context),
_hexagonTargetLayout(layout),
_hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(context)) {}
HexagonLinkingContext &ctx, HexagonTargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(ctx, layout), HexagonELFWriter<ELFT>(ctx, layout),
_ctx(ctx), _hexagonTargetLayout(layout),
_hexagonRuntimeFile(new HexagonRuntimeFile<ELFT>(ctx)) {}
template <class ELFT>
bool HexagonExecutableWriter<ELFT>::createImplicitFiles(

4
lld/lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h
View File

@ -20,9 +20,9 @@ class HexagonLinkingContext;
template <class HexagonELFType>
class SDataSection : public AtomSection<HexagonELFType> {
public:
SDataSection(const HexagonLinkingContext &context)
SDataSection(const HexagonLinkingContext &ctx)
: AtomSection<HexagonELFType>(
context, ".sdata", DefinedAtom::typeDataFast, 0,
ctx, ".sdata", DefinedAtom::typeDataFast, 0,
HexagonTargetLayout<HexagonELFType>::ORDER_SDATA) {
this->_type = SHT_PROGBITS;
this->_flags = SHF_ALLOC | SHF_WRITE;

18
lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
View File

@ -18,21 +18,21 @@ using namespace llvm::ELF;
using llvm::makeArrayRef;
HexagonTargetHandler::HexagonTargetHandler(HexagonLinkingContext &context)
: _hexagonLinkingContext(context),
_hexagonRuntimeFile(new HexagonRuntimeFile<HexagonELFType>(context)),
_hexagonTargetLayout(new HexagonTargetLayout<HexagonELFType>(context)),
_hexagonRelocationHandler(new HexagonTargetRelocationHandler(
*_hexagonTargetLayout.get())) {}
HexagonTargetHandler::HexagonTargetHandler(HexagonLinkingContext &ctx)
: _ctx(ctx),
_hexagonRuntimeFile(new HexagonRuntimeFile<HexagonELFType>(ctx)),
_hexagonTargetLayout(new HexagonTargetLayout<HexagonELFType>(ctx)),
_hexagonRelocationHandler(
new HexagonTargetRelocationHandler(*_hexagonTargetLayout.get())) {}
std::unique_ptr<Writer> HexagonTargetHandler::getWriter() {
switch (_hexagonLinkingContext.getOutputELFType()) {
switch (_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<HexagonExecutableWriter<HexagonELFType>>(
_hexagonLinkingContext, *_hexagonTargetLayout.get());
_ctx, *_hexagonTargetLayout.get());
case llvm::ELF::ET_DYN:
return llvm::make_unique<HexagonDynamicLibraryWriter<HexagonELFType>>(
_hexagonLinkingContext, *_hexagonTargetLayout.get());
_ctx, *_hexagonTargetLayout.get());
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:

8
lld/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
View File

@ -118,13 +118,11 @@ public:
}
std::unique_ptr<Reader> getObjReader() override {
return std::unique_ptr<Reader>(
new HexagonELFObjectReader(_hexagonLinkingContext));
return std::unique_ptr<Reader>(new HexagonELFObjectReader(_ctx));
}
std::unique_ptr<Reader> getDSOReader() override {
return std::unique_ptr<Reader>(
new HexagonELFDSOReader(_hexagonLinkingContext));
return std::unique_ptr<Reader>(new HexagonELFDSOReader(_ctx));
}
std::unique_ptr<Writer> getWriter() override;
@ -132,7 +130,7 @@ public:
private:
llvm::BumpPtrAllocator _alloc;
static const Registry::KindStrings kindStrings[];
HexagonLinkingContext &_hexagonLinkingContext;
HexagonLinkingContext &_ctx;
std::unique_ptr<HexagonRuntimeFile<HexagonELFType> > _hexagonRuntimeFile;
std::unique_ptr<HexagonTargetLayout<HexagonELFType>> _hexagonTargetLayout;
std::unique_ptr<HexagonTargetRelocationHandler> _hexagonRelocationHandler;

12
lld/lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h
View File

@ -74,16 +74,16 @@ void MipsDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
template <class ELFT>
unique_bump_ptr<SymbolTable<ELFT>>
MipsDynamicLibraryWriter<ELFT>::createSymbolTable() {
return unique_bump_ptr<SymbolTable<ELFT>>(new (
this->_alloc) MipsSymbolTable<ELFT>(this->_context));
return unique_bump_ptr<SymbolTable<ELFT>>(
new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
}
/// \brief create dynamic table
template <class ELFT>
unique_bump_ptr<DynamicTable<ELFT>>
MipsDynamicLibraryWriter<ELFT>::createDynamicTable() {
return unique_bump_ptr<DynamicTable<ELFT>>(new (
this->_alloc) MipsDynamicTable<ELFT>(this->_context, _mipsTargetLayout));
return unique_bump_ptr<DynamicTable<ELFT>>(
new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _mipsTargetLayout));
}
/// \brief create dynamic symbol table
@ -91,8 +91,8 @@ template <class ELFT>
unique_bump_ptr<DynamicSymbolTable<ELFT>>
MipsDynamicLibraryWriter<ELFT>::createDynamicSymbolTable() {
return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
new (this->_alloc) MipsDynamicSymbolTable<ELFT>(
this->_context, _mipsTargetLayout));
new (this->_alloc)
MipsDynamicSymbolTable<ELFT>(this->_ctx, _mipsTargetLayout));
}
} // namespace elf

18
lld/lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h
View File

@ -56,7 +56,7 @@ std::error_code MipsExecutableWriter<ELFT>::setELFHeader() {
if (ec)
return ec;
StringRef entryName = this->_context.entrySymbolName();
StringRef entryName = this->_ctx.entrySymbolName();
if (const AtomLayout *al = this->_layout.findAtomLayoutByName(entryName)) {
const auto *ea = cast<DefinedAtom>(al->_atom);
if (ea->codeModel() == DefinedAtom::codeMipsMicro ||
@ -87,8 +87,8 @@ void MipsExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
continue;
if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
!this->_context.isDynamicallyExportedSymbol(da->name()) &&
!(this->_context.shouldExportDynamic() &&
!this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
!(this->_ctx.shouldExportDynamic() &&
da->scope() == Atom::Scope::scopeGlobal))
continue;
@ -127,16 +127,16 @@ void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
template <class ELFT>
unique_bump_ptr<SymbolTable<ELFT>>
MipsExecutableWriter<ELFT>::createSymbolTable() {
return unique_bump_ptr<SymbolTable<ELFT>>(new (
this->_alloc) MipsSymbolTable<ELFT>(this->_context));
return unique_bump_ptr<SymbolTable<ELFT>>(
new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
}
/// \brief create dynamic table
template <class ELFT>
unique_bump_ptr<DynamicTable<ELFT>>
MipsExecutableWriter<ELFT>::createDynamicTable() {
return unique_bump_ptr<DynamicTable<ELFT>>(new (
this->_alloc) MipsDynamicTable<ELFT>(this->_context, _mipsTargetLayout));
return unique_bump_ptr<DynamicTable<ELFT>>(
new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _mipsTargetLayout));
}
/// \brief create dynamic symbol table
@ -144,8 +144,8 @@ template <class ELFT>
unique_bump_ptr<DynamicSymbolTable<ELFT>>
MipsExecutableWriter<ELFT>::createDynamicSymbolTable() {
return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
new (this->_alloc) MipsDynamicSymbolTable<ELFT>(
this->_context, _mipsTargetLayout));
new (this->_alloc)
MipsDynamicSymbolTable<ELFT>(this->_ctx, _mipsTargetLayout));
}
} // namespace elf

6
lld/lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h
View File

@ -139,9 +139,9 @@ template <class ELFT> class MipsRelocationTable : public RelocationTable<ELFT> {
ELFT::Is64Bits && ELFT::TargetEndianness == llvm::support::little;
public:
MipsRelocationTable(const ELFLinkingContext &context, StringRef str,
MipsRelocationTable(const ELFLinkingContext &ctx, StringRef str,
int32_t order)
: RelocationTable<ELFT>(context, str, order) {}
: RelocationTable<ELFT>(ctx, str, order) {}
protected:
void writeRela(ELFWriter *writer, Elf_Rela &r, const DefinedAtom &atom,
@ -150,7 +150,7 @@ protected:
r.setSymbolAndType(this->getSymbolIndex(ref.target()), rType, _isMips64EL);
r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
// The addend is used only by relative relocations
if (this->_context.isRelativeReloc(ref))
if (this->_ctx.isRelativeReloc(ref))
r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
else
r.r_addend = 0;

5
lld/lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h
View File

@ -77,9 +77,8 @@ public:
protected:
unique_bump_ptr<RelocationTable<ELFT>>
createRelocationTable(StringRef name, int32_t order) override {
return unique_bump_ptr<RelocationTable<ELFT>>(
new (this->_allocator)
MipsRelocationTable<ELFT>(this->_context, name, order));
return unique_bump_ptr<RelocationTable<ELFT>>(new (
this->_allocator) MipsRelocationTable<ELFT>(this->_ctx, name, order));
}
private:

86
lld/lib/ReaderWriter/ELF/OutputELFWriter.h
View File

@ -35,9 +35,9 @@ namespace {
template<class ELFT>
class SymbolFile : public RuntimeFile<ELFT> {
public:
SymbolFile(ELFLinkingContext &context)
: RuntimeFile<ELFT>(context, "Dynamic absolute symbols"),
_atomsAdded(false) {}
SymbolFile(ELFLinkingContext &ctx)
: RuntimeFile<ELFT>(ctx, "Dynamic absolute symbols"), _atomsAdded(false) {
}
Atom *addAbsoluteAtom(StringRef symbolName) override {
auto *a = RuntimeFile<ELFT>::addAbsoluteAtom(symbolName);
@ -59,13 +59,13 @@ template<class ELFT>
class DynamicSymbolFile : public SimpleArchiveLibraryFile {
typedef std::function<void(StringRef, RuntimeFile<ELFT> &)> Resolver;
public:
DynamicSymbolFile(ELFLinkingContext &context, Resolver resolver)
DynamicSymbolFile(ELFLinkingContext &ctx, Resolver resolver)
: SimpleArchiveLibraryFile("Dynamically added runtime symbols"),
_context(context), _resolver(resolver) {}
_ctx(ctx), _resolver(resolver) {}
File *find(StringRef sym, bool dataSymbolOnly) override {
if (!_file)
_file.reset(new (_alloc) SymbolFile<ELFT>(_context));
_file.reset(new (_alloc) SymbolFile<ELFT>(_ctx));
assert(!_file->hasAtoms() && "The file shouldn't have atoms yet");
_resolver(sym, *_file);
@ -74,7 +74,7 @@ public:
}
private:
ELFLinkingContext &_context;
ELFLinkingContext &_ctx;
Resolver _resolver;
// The allocator should go before bump pointers because of
@ -99,7 +99,7 @@ public:
typedef Elf_Sym_Impl<ELFT> Elf_Sym;
typedef Elf_Dyn_Impl<ELFT> Elf_Dyn;
OutputELFWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout);
OutputELFWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout);
protected:
// build the sections that need to be created
@ -184,7 +184,7 @@ protected:
llvm::BumpPtrAllocator _alloc;
ELFLinkingContext &_context;
ELFLinkingContext &_ctx;
TargetHandler<ELFT> &_targetHandler;
typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
@ -215,11 +215,10 @@ private:
// OutputELFWriter
//===----------------------------------------------------------------------===//
template <class ELFT>
OutputELFWriter<ELFT>::OutputELFWriter(ELFLinkingContext &context,
OutputELFWriter<ELFT>::OutputELFWriter(ELFLinkingContext &ctx,
TargetLayout<ELFT> &layout)
: _context(context), _targetHandler(context.getTargetHandler<ELFT>()),
_layout(layout),
_scriptFile(new RuntimeFile<ELFT>(context, "Linker script runtime")) {}
: _ctx(ctx), _targetHandler(ctx.getTargetHandler<ELFT>()), _layout(layout),
_scriptFile(new RuntimeFile<ELFT>(ctx, "Linker script runtime")) {}
template <class ELFT>
void OutputELFWriter<ELFT>::buildChunks(const File &file) {
@ -274,20 +273,20 @@ void OutputELFWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
if (isNeededTagRequired(sla))
_soNeeded.insert(sla->loadName());
}
for (const std::unique_ptr<Node> &node : _context.getNodes()) {
for (const std::unique_ptr<Node> &node : _ctx.getNodes()) {
StringRef soname = maybeGetSOName(node.get());
if (!soname.empty())
_soNeeded.insert(soname);
}
// Never mark the dynamic linker as DT_NEEDED
_soNeeded.erase(sys::path::filename(_context.getInterpreter()));
_soNeeded.erase(sys::path::filename(_ctx.getInterpreter()));
for (const auto &loadName : _soNeeded) {
Elf_Dyn dyn;
dyn.d_tag = DT_NEEDED;
dyn.d_un.d_val = _dynamicStringTable->addString(loadName.getKey());
_dynamicTable->addEntry(dyn);
}
const auto &rpathList = _context.getRpathList();
const auto &rpathList = _ctx.getRpathList();
if (!rpathList.empty()) {
auto rpath = new (_alloc) std::string(join(rpathList.begin(),
rpathList.end(), ":"));
@ -296,8 +295,8 @@ void OutputELFWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
dyn.d_un.d_val = _dynamicStringTable->addString(*rpath);
_dynamicTable->addEntry(dyn);
}
StringRef soname = _context.sharedObjectName();
if (!soname.empty() && _context.getOutputELFType() == llvm::ELF::ET_DYN) {
StringRef soname = _ctx.sharedObjectName();
if (!soname.empty() && _ctx.getOutputELFType() == llvm::ELF::ET_DYN) {
Elf_Dyn dyn;
dyn.d_tag = DT_SONAME;
dyn.d_un.d_val = _dynamicStringTable->addString(soname);
@ -367,7 +366,7 @@ void OutputELFWriter<ELFT>::assignSectionsWithNoSegments() {
template <class ELFT> void OutputELFWriter<ELFT>::addDefaultAtoms() {
const llvm::StringSet<> &symbols =
_context.linkerScriptSema().getScriptDefinedSymbols();
_ctx.linkerScriptSema().getScriptDefinedSymbols();
for (auto &sym : symbols)
_scriptFile->addAbsoluteAtom(sym.getKey());
}
@ -380,7 +379,7 @@ bool OutputELFWriter<ELFT>::createImplicitFiles(
auto callback = [this](StringRef sym, RuntimeFile<ELFT> &file) {
processUndefinedSymbol(sym, file);
};
auto &ctx = const_cast<ELFLinkingContext &>(_context);
auto &ctx = const_cast<ELFLinkingContext &>(_ctx);
ctx.setUndefinesResolver(
llvm::make_unique<DynamicSymbolFile<ELFT>>(ctx, std::move(callback)));
// Add script defined symbols
@ -391,28 +390,28 @@ bool OutputELFWriter<ELFT>::createImplicitFiles(
template <class ELFT>
void OutputELFWriter<ELFT>::finalizeDefaultAtomValues() {
const llvm::StringSet<> &symbols =
_context.linkerScriptSema().getScriptDefinedSymbols();
_ctx.linkerScriptSema().getScriptDefinedSymbols();
for (auto &sym : symbols) {
uint64_t res =
_context.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
_ctx.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
auto a = _layout.findAbsoluteAtom(sym.getKey());
(*a)->_virtualAddr = res;
}
}
template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
_elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_context));
_programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_context));
_elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_ctx));
_programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_ctx));
_layout.setHeader(_elfHeader.get());
_layout.setProgramHeader(_programHeader.get());
_symtab = std::move(this->createSymbolTable());
_strtab.reset(new (_alloc) StringTable<ELFT>(
_context, ".strtab", DefaultLayout<ELFT>::ORDER_STRING_TABLE));
_ctx, ".strtab", DefaultLayout<ELFT>::ORDER_STRING_TABLE));
_shstrtab.reset(new (_alloc) StringTable<ELFT>(
_context, ".shstrtab", DefaultLayout<ELFT>::ORDER_SECTION_STRINGS));
_ctx, ".shstrtab", DefaultLayout<ELFT>::ORDER_SECTION_STRINGS));
_shdrtab.reset(new (_alloc) SectionHeader<ELFT>(
_context, DefaultLayout<ELFT>::ORDER_SECTION_HEADERS));
_ctx, DefaultLayout<ELFT>::ORDER_SECTION_HEADERS));
_layout.addSection(_symtab.get());
_layout.addSection(_strtab.get());
_layout.addSection(_shstrtab.get());
@ -426,19 +425,19 @@ template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
if (!section || section->outputSectionName() != ".eh_frame")
continue;
_ehFrameHeader.reset(new (_alloc) EHFrameHeader<ELFT>(
_context, ".eh_frame_hdr", _layout,
_ctx, ".eh_frame_hdr", _layout,
DefaultLayout<ELFT>::ORDER_EH_FRAMEHDR));
_layout.addSection(_ehFrameHeader.get());
break;
}
if (_context.isDynamic()) {
if (_ctx.isDynamic()) {
_dynamicTable = std::move(createDynamicTable());
_dynamicStringTable.reset(new (_alloc) StringTable<ELFT>(
_context, ".dynstr", DefaultLayout<ELFT>::ORDER_DYNAMIC_STRINGS, true));
_ctx, ".dynstr", DefaultLayout<ELFT>::ORDER_DYNAMIC_STRINGS, true));
_dynamicSymbolTable = std::move(createDynamicSymbolTable());
_hashTable.reset(new (_alloc) HashSection<ELFT>(
_context, ".hash", DefaultLayout<ELFT>::ORDER_HASH));
_ctx, ".hash", DefaultLayout<ELFT>::ORDER_HASH));
// Set the hash table in the dynamic symbol table so that the entries in the
// hash table can be created
_dynamicSymbolTable->setHashTable(_hashTable.get());
@ -463,16 +462,15 @@ template <class ELFT>
unique_bump_ptr<SymbolTable<ELFT>>
OutputELFWriter<ELFT>::createSymbolTable() {
return unique_bump_ptr<SymbolTable<ELFT>>(new (_alloc) SymbolTable<ELFT>(
this->_context, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
this->_ctx, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
}
/// \brief create dynamic table
template <class ELFT>
unique_bump_ptr<DynamicTable<ELFT>>
OutputELFWriter<ELFT>::createDynamicTable() {
return unique_bump_ptr<DynamicTable<ELFT>>(
new (_alloc) DynamicTable<ELFT>(
this->_context, _layout, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
return unique_bump_ptr<DynamicTable<ELFT>>(new (_alloc) DynamicTable<ELFT>(
this->_ctx, _layout, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
}
/// \brief create dynamic symbol table
@ -480,9 +478,9 @@ template <class ELFT>
unique_bump_ptr<DynamicSymbolTable<ELFT>>
OutputELFWriter<ELFT>::createDynamicSymbolTable() {
return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
new (_alloc) DynamicSymbolTable<ELFT>(
this->_context, _layout, ".dynsym",
DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
new (_alloc)
DynamicSymbolTable<ELFT>(this->_ctx, _layout, ".dynsym",
DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
}
template <class ELFT>
@ -498,7 +496,7 @@ std::error_code OutputELFWriter<ELFT>::buildOutput(const File &file) {
_layout.assignSectionsToSegments();
// Create the dynamic table entries
if (_context.isDynamic()) {
if (_ctx.isDynamic()) {
_dynamicTable->createDefaultEntries();
buildDynamicSymbolTable(file);
}
@ -517,7 +515,7 @@ std::error_code OutputELFWriter<ELFT>::buildOutput(const File &file) {
// Create symbol table and section string table
// Do it only if -s is not specified.
if (!_context.stripSymbols())
if (!_ctx.stripSymbols())
buildStaticSymbolTable(file);
// Finalize the layout by calling the finalize() functions
@ -530,15 +528,15 @@ std::error_code OutputELFWriter<ELFT>::buildOutput(const File &file) {
// for sections with no segments
assignSectionsWithNoSegments();
if (_context.isDynamic())
if (_ctx.isDynamic())
_dynamicTable->updateDynamicTable();
return std::error_code();
}
template <class ELFT> std::error_code OutputELFWriter<ELFT>::setELFHeader() {
_elfHeader->e_type(_context.getOutputELFType());
_elfHeader->e_machine(_context.getOutputMachine());
_elfHeader->e_type(_ctx.getOutputELFType());
_elfHeader->e_machine(_ctx.getOutputMachine());
_elfHeader->e_ident(ELF::EI_VERSION, 1);
_elfHeader->e_ident(ELF::EI_OSABI, 0);
_elfHeader->e_version(1);
@ -549,7 +547,7 @@ template <class ELFT> std::error_code OutputELFWriter<ELFT>::setELFHeader() {
_elfHeader->e_shentsize(_shdrtab->entsize());
_elfHeader->e_shnum(_shdrtab->numHeaders());
_elfHeader->e_shstrndx(_shstrtab->ordinal());
if (const auto *al = _layout.findAtomLayoutByName(_context.entrySymbolName()))
if (const auto *al = _layout.findAtomLayoutByName(_ctx.entrySymbolName()))
_elfHeader->e_entry(al->_virtualAddr);
else
_elfHeader->e_entry(0);

69
lld/lib/ReaderWriter/ELF/SectionChunks.h
View File

@ -39,10 +39,10 @@ template <class ELFT> class Segment;
/// \brief An ELF section.
template <class ELFT> class Section : public Chunk<ELFT> {
public:
Section(const ELFLinkingContext &context, StringRef sectionName,
Section(const ELFLinkingContext &ctx, StringRef sectionName,
StringRef chunkName,
typename Chunk<ELFT>::Kind k = Chunk<ELFT>::Kind::ELFSection)
: Chunk<ELFT>(chunkName, k, context), _outputSection(nullptr), _flags(0),
: Chunk<ELFT>(chunkName, k, ctx), _outputSection(nullptr), _flags(0),
_entSize(0), _type(0), _link(0), _info(0),
_isFirstSectionInOutputSection(false), _segmentType(SHT_NULL),
_inputSectionName(sectionName), _outputSectionName(sectionName) {}
@ -159,9 +159,9 @@ protected:
/// \brief A section containing atoms.
template <class ELFT> class AtomSection : public Section<ELFT> {
public:
AtomSection(const ELFLinkingContext &context, StringRef sectionName,
AtomSection(const ELFLinkingContext &ctx, StringRef sectionName,
int32_t contentType, int32_t permissions, int32_t order)
: Section<ELFT>(context, sectionName, "AtomSection",
: Section<ELFT>(ctx, sectionName, "AtomSection",
Chunk<ELFT>::Kind::AtomSection),
_contentType(contentType), _contentPermissions(permissions),
_isLoadedInMemory(true) {
@ -283,10 +283,8 @@ protected:
void printError(const std::string &errorStr, const AtomLayout &atom,
const Reference &ref) const {
StringRef kindValStr;
if (!this->_context.registry().referenceKindToString(ref.kindNamespace(),
ref.kindArch(),
ref.kindValue(),
kindValStr)) {
if (!this->_ctx.registry().referenceKindToString(
ref.kindNamespace(), ref.kindArch(), ref.kindValue(), kindValStr)) {
kindValStr = "unknown";
}
@ -429,7 +427,7 @@ void AtomSection<ELFT>::write(ELFWriter *writer, TargetLayout<ELFT> &layout,
uint8_t *atomContent = chunkBuffer + ai->_fileOffset;
std::memcpy(atomContent, content.data(), contentSize);
const TargetRelocationHandler &relHandler =
this->_context.template getTargetHandler<ELFT>().getRelocationHandler();
this->_ctx.template getTargetHandler<ELFT>().getRelocationHandler();
for (const auto ref : *definedAtom) {
if (std::error_code ec = relHandler.applyRelocation(*writer, buffer,
*ai, *ref)) {
@ -599,9 +597,9 @@ private:
};
template <class ELFT>
StringTable<ELFT>::StringTable(const ELFLinkingContext &context,
const char *str, int32_t order, bool dynamic)
: Section<ELFT>(context, str, "StringTable") {
StringTable<ELFT>::StringTable(const ELFLinkingContext &ctx, const char *str,
int32_t order, bool dynamic)
: Section<ELFT>(ctx, str, "StringTable") {
// the string table has a NULL entry for which
// add an empty string
_strings.push_back("");
@ -653,7 +651,7 @@ class SymbolTable : public Section<ELFT> {
public:
typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
SymbolTable(const ELFLinkingContext &context, const char *str, int32_t order);
SymbolTable(const ELFLinkingContext &ctx, const char *str, int32_t order);
/// \brief set the number of entries that would exist in the symbol
/// table for the current link
@ -723,9 +721,9 @@ protected:
/// ELF Symbol Table
template <class ELFT>
SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &context,
const char *str, int32_t order)
: Section<ELFT>(context, str, "SymbolTable") {
SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &ctx, const char *str,
int32_t order)
: Section<ELFT>(ctx, str, "SymbolTable") {
this->setOrder(order);
Elf_Sym symbol;
std::memset(&symbol, 0, sizeof(Elf_Sym));
@ -907,9 +905,9 @@ template <class ELFT> class HashSection;
template <class ELFT> class DynamicSymbolTable : public SymbolTable<ELFT> {
public:
DynamicSymbolTable(const ELFLinkingContext &context,
TargetLayout<ELFT> &layout, const char *str, int32_t order)
: SymbolTable<ELFT>(context, str, order), _hashTable(nullptr),
DynamicSymbolTable(const ELFLinkingContext &ctx, TargetLayout<ELFT> &layout,
const char *str, int32_t order)
: SymbolTable<ELFT>(ctx, str, order), _hashTable(nullptr),
_layout(layout) {
this->_type = SHT_DYNSYM;
this->_flags = SHF_ALLOC;
@ -956,14 +954,13 @@ public:
typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
RelocationTable(const ELFLinkingContext &context, StringRef str,
int32_t order)
: Section<ELFT>(context, str, "RelocationTable"), _symbolTable(nullptr) {
RelocationTable(const ELFLinkingContext &ctx, StringRef str, int32_t order)
: Section<ELFT>(ctx, str, "RelocationTable"), _symbolTable(nullptr) {
this->setOrder(order);
this->_flags = SHF_ALLOC;
// Set the alignment properly depending on the target architecture
this->_alignment = ELFT::Is64Bits ? 8 : 4;
if (context.isRelaOutputFormat()) {
if (ctx.isRelaOutputFormat()) {
this->_entSize = sizeof(Elf_Rela);
this->_type = SHT_RELA;
} else {
@ -1019,7 +1016,7 @@ public:
uint8_t *chunkBuffer = buffer.getBufferStart();
uint8_t *dest = chunkBuffer + this->fileOffset();
for (const auto &rel : _relocs) {
if (this->_context.isRelaOutputFormat()) {
if (this->_ctx.isRelaOutputFormat()) {
auto &r = *reinterpret_cast<Elf_Rela *>(dest);
writeRela(writer, r, *rel.first, *rel.second);
DEBUG_WITH_TYPE("ELFRelocationTable",
@ -1049,7 +1046,7 @@ protected:
r.setSymbolAndType(getSymbolIndex(ref.target()), ref.kindValue(), false);
r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
// The addend is used only by relative relocations
if (this->_context.isRelativeReloc(ref))
if (this->_ctx.isRelativeReloc(ref))
r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
else
r.r_addend = 0;
@ -1077,9 +1074,9 @@ public:
typedef llvm::object::Elf_Dyn_Impl<ELFT> Elf_Dyn;
typedef std::vector<Elf_Dyn> EntriesT;
DynamicTable(const ELFLinkingContext &context, TargetLayout<ELFT> &layout,
DynamicTable(const ELFLinkingContext &ctx, TargetLayout<ELFT> &layout,
StringRef str, int32_t order)
: Section<ELFT>(context, str, "DynamicSection"), _layout(layout) {
: Section<ELFT>(ctx, str, "DynamicSection"), _layout(layout) {
this->setOrder(order);
this->_entSize = sizeof(Elf_Dyn);
this->_alignment = ELFT::Is64Bits ? 8 : 4;
@ -1113,7 +1110,7 @@ public:
}
virtual void createDefaultEntries() {
bool isRela = this->_context.isRelaOutputFormat();
bool isRela = this->_ctx.isRelaOutputFormat();
Elf_Dyn dyn;
dyn.d_un.d_val = 0;
@ -1280,14 +1277,14 @@ private:
HashSection<ELFT> *_hashTable;
const AtomLayout *getInitAtomLayout() {
auto al = _layout.findAtomLayoutByName(this->_context.initFunction());
auto al = _layout.findAtomLayoutByName(this->_ctx.initFunction());
if (al && isa<DefinedAtom>(al->_atom))
return al;
return nullptr;
}
const AtomLayout *getFiniAtomLayout() {
auto al = _layout.findAtomLayoutByName(this->_context.finiFunction());
auto al = _layout.findAtomLayoutByName(this->_ctx.finiFunction());
if (al && isa<DefinedAtom>(al->_atom))
return al;
return nullptr;
@ -1296,9 +1293,9 @@ private:
template <class ELFT> class InterpSection : public Section<ELFT> {
public:
InterpSection(const ELFLinkingContext &context, StringRef str, int32_t order,
InterpSection(const ELFLinkingContext &ctx, StringRef str, int32_t order,
StringRef interp)
: Section<ELFT>(context, str, "Dynamic:Interp"), _interp(interp) {
: Section<ELFT>(ctx, str, "Dynamic:Interp"), _interp(interp) {
this->setOrder(order);
this->_alignment = 1;
// + 1 for null term.
@ -1346,8 +1343,8 @@ template <class ELFT> class HashSection : public Section<ELFT> {
};
public:
HashSection(const ELFLinkingContext &context, StringRef name, int32_t order)
: Section<ELFT>(context, name, "Dynamic:Hash"), _symbolTable(nullptr) {
HashSection(const ELFLinkingContext &ctx, StringRef name, int32_t order)
: Section<ELFT>(ctx, name, "Dynamic:Hash"), _symbolTable(nullptr) {
this->setOrder(order);
this->_entSize = 4;
this->_type = SHT_HASH;
@ -1449,9 +1446,9 @@ private:
template <class ELFT> class EHFrameHeader : public Section<ELFT> {
public:
EHFrameHeader(const ELFLinkingContext &context, StringRef name,
EHFrameHeader(const ELFLinkingContext &ctx, StringRef name,
TargetLayout<ELFT> &layout, int32_t order)
: Section<ELFT>(context, name, "EHFrameHeader"), _ehFrameOffset(0),
: Section<ELFT>(ctx, name, "EHFrameHeader"), _ehFrameOffset(0),
_layout(layout) {
this->setOrder(order);
this->_entSize = 0;

34
lld/lib/ReaderWriter/ELF/SegmentChunks.h
View File

@ -100,7 +100,7 @@ public:
typedef typename std::vector<SegmentSlice<ELFT> *>::iterator SliceIter;
typedef typename std::vector<Chunk<ELFT> *>::iterator SectionIter;
Segment(const ELFLinkingContext &context, StringRef name,
Segment(const ELFLinkingContext &ctx, StringRef name,
const Layout::SegmentType type);
/// \brief the Order of segments that appear in the output file
@ -209,7 +209,7 @@ public:
}
}
int pageSize() const { return this->_context.getPageSize(); }
int pageSize() const { return this->_ctx.getPageSize(); }
int rawflags() const { return _atomflags; }
@ -304,8 +304,8 @@ private:
/// The segment doesn't contain any slice
template <class ELFT> class ProgramHeaderSegment : public Segment<ELFT> {
public:
ProgramHeaderSegment(const ELFLinkingContext &context)
: Segment<ELFT>(context, "PHDR", llvm::ELF::PT_PHDR) {
ProgramHeaderSegment(const ELFLinkingContext &ctx)
: Segment<ELFT>(ctx, "PHDR", llvm::ELF::PT_PHDR) {
this->_alignment = 8;
this->_flags = (llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR);
}
@ -326,13 +326,13 @@ public:
};
template <class ELFT>
Segment<ELFT>::Segment(const ELFLinkingContext &context, StringRef name,
Segment<ELFT>::Segment(const ELFLinkingContext &ctx, StringRef name,
const Layout::SegmentType type)
: Chunk<ELFT>(name, Chunk<ELFT>::Kind::ELFSegment, context),
_segmentType(type), _flags(0), _atomflags(0) {
: Chunk<ELFT>(name, Chunk<ELFT>::Kind::ELFSegment, ctx), _segmentType(type),
_flags(0), _atomflags(0) {
this->_alignment = 0;
this->_fsize = 0;
_outputMagic = context.getOutputMagic();
_outputMagic = ctx.getOutputMagic();
}
// This function actually is used, but not in all instantiations of Segment.
@ -419,8 +419,8 @@ void Segment<ELFT>::assignFileOffsets(uint64_t startOffset) {
uint64_t fileOffset = startOffset;
uint64_t curSliceFileOffset = fileOffset;
bool isDataPageAlignedForNMagic = false;
bool alignSegments = this->_context.alignSegments();
uint64_t p_align = this->_context.getPageSize();
bool alignSegments = this->_ctx.alignSegments();
uint64_t p_align = this->_ctx.getPageSize();
uint64_t lastVirtualAddress = 0;
this->setFileOffset(startOffset);
@ -455,7 +455,7 @@ void Segment<ELFT>::assignFileOffsets(uint64_t startOffset) {
}
} else if (!isDataPageAlignedForNMagic && needAlign(section)) {
fileOffset =
llvm::RoundUpToAlignment(fileOffset, this->_context.getPageSize());
llvm::RoundUpToAlignment(fileOffset, this->_ctx.getPageSize());
isDataPageAlignedForNMagic = true;
}
if (isFirstSection) {
@ -493,7 +493,7 @@ template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
uint64_t startAddr = addr;
SegmentSlice<ELFT> *slice = nullptr;
uint64_t tlsStartAddr = 0;
bool alignSegments = this->_context.alignSegments();
bool alignSegments = this->_ctx.alignSegments();
StringRef prevOutputSectionName = StringRef();
for (auto si = _sections.begin(); si != _sections.end(); ++si) {
@ -508,12 +508,12 @@ template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
// Align to a page only if the output is not
// OutputMagic::NMAGIC/OutputMagic::OMAGIC
startAddr =
llvm::RoundUpToAlignment(startAddr, this->_context.getPageSize());
llvm::RoundUpToAlignment(startAddr, this->_ctx.getPageSize());
else if (!isDataPageAlignedForNMagic && needAlign(*si)) {
// If the linker outputmagic is set to OutputMagic::NMAGIC, align the
// Data to a page boundary.
startAddr =
llvm::RoundUpToAlignment(startAddr, this->_context.getPageSize());
llvm::RoundUpToAlignment(startAddr, this->_ctx.getPageSize());
isDataPageAlignedForNMagic = true;
}
// align the startOffset to the section alignment
@ -549,8 +549,7 @@ template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
// If the linker outputmagic is set to OutputMagic::NMAGIC, align the
// Data
// to a page boundary
curAddr =
llvm::RoundUpToAlignment(curAddr, this->_context.getPageSize());
curAddr = llvm::RoundUpToAlignment(curAddr, this->_ctx.getPageSize());
isDataPageAlignedForNMagic = true;
}
uint64_t newAddr = llvm::RoundUpToAlignment(curAddr, (*si)->alignment());
@ -577,8 +576,7 @@ template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
// a separate segment, so that memory is not used up while running.
// Dont create a slice, if the new section falls in the same output
// section as the previous section.
if (autoCreateSlice &&
((newAddr - curAddr) > this->_context.getPageSize()) &&
if (autoCreateSlice && ((newAddr - curAddr) > this->_ctx.getPageSize()) &&
(_outputMagic != ELFLinkingContext::OutputMagic::NMAGIC &&
_outputMagic != ELFLinkingContext::OutputMagic::OMAGIC)) {
auto sliceIter =

2
lld/lib/ReaderWriter/ELF/TargetLayout.h
View File

@ -20,7 +20,7 @@ namespace elf {
/// be changed in the final layout
template <class ELFT> class TargetLayout : public DefaultLayout<ELFT> {
public:
TargetLayout(ELFLinkingContext &context) : DefaultLayout<ELFT>(context) {}
TargetLayout(ELFLinkingContext &ctx) : DefaultLayout<ELFT>(ctx) {}
};
} // end namespace elf
} // end namespace lld

10
lld/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
View File

@ -18,7 +18,7 @@ namespace elf {
template <class ELFT>
class X86DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
public:
X86DynamicLibraryWriter(X86LinkingContext &context,
X86DynamicLibraryWriter(X86LinkingContext &ctx,
X86TargetLayout<ELFT> &layout);
protected:
@ -41,15 +41,15 @@ private:
};
std::unique_ptr<GOTFile> _gotFile;
X86LinkingContext &_context;
X86LinkingContext &_ctx;
X86TargetLayout<ELFT> &_x86Layout;
};
template <class ELFT>
X86DynamicLibraryWriter<ELFT>::X86DynamicLibraryWriter(
X86LinkingContext &context, X86TargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(context, layout),
_gotFile(new GOTFile(context)), _context(context), _x86Layout(layout) {}
X86LinkingContext &ctx, X86TargetLayout<ELFT> &layout)
: DynamicLibraryWriter<ELFT>(ctx, layout), _gotFile(new GOTFile(ctx)),
_ctx(ctx), _x86Layout(layout) {}
template <class ELFT>
bool X86DynamicLibraryWriter<ELFT>::createImplicitFiles(

10
lld/lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h
View File

@ -18,8 +18,7 @@ namespace elf {
template <class ELFT>
class X86ExecutableWriter : public ExecutableWriter<ELFT> {
public:
X86ExecutableWriter(X86LinkingContext &context,
X86TargetLayout<ELFT> &layout);
X86ExecutableWriter(X86LinkingContext &ctx, X86TargetLayout<ELFT> &layout);
protected:
// Add any runtime files and their atoms to the output
@ -34,15 +33,14 @@ protected:
}
private:
X86LinkingContext &_context;
X86LinkingContext &_ctx;
X86TargetLayout<ELFT> &_x86Layout;
};
template <class ELFT>
X86ExecutableWriter<ELFT>::X86ExecutableWriter(X86LinkingContext &context,
X86ExecutableWriter<ELFT>::X86ExecutableWriter(X86LinkingContext &ctx,
X86TargetLayout<ELFT> &layout)
: ExecutableWriter<ELFT>(context, layout), _context(context),
_x86Layout(layout) {}
: ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _x86Layout(layout) {}
template <class ELFT>
bool X86ExecutableWriter<ELFT>::createImplicitFiles(

11
lld/lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp
View File

@ -19,13 +19,13 @@ using namespace elf;
using namespace llvm::ELF;
std::unique_ptr<Writer> X86TargetHandler::getWriter() {
switch (_x86LinkingContext.getOutputELFType()) {
switch (_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<X86ExecutableWriter<X86ELFType>>(
_x86LinkingContext, *_x86TargetLayout.get());
_ctx, *_x86TargetLayout.get());
case llvm::ELF::ET_DYN:
return llvm::make_unique<X86DynamicLibraryWriter<X86ELFType>>(
_x86LinkingContext, *_x86TargetLayout.get());
_ctx, *_x86TargetLayout.get());
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:
@ -47,7 +47,6 @@ void X86TargetHandler::registerRelocationNames(Registry &registry) {
kindStrings);
}
X86TargetHandler::X86TargetHandler(X86LinkingContext &context)
: _x86LinkingContext(context),
_x86TargetLayout(new X86TargetLayout<X86ELFType>(context)),
X86TargetHandler::X86TargetHandler(X86LinkingContext &ctx)
: _ctx(ctx), _x86TargetLayout(new X86TargetLayout<X86ELFType>(ctx)),
_x86RelocationHandler(new X86TargetRelocationHandler()) {}

10
lld/lib/ReaderWriter/ELF/X86/X86TargetHandler.h
View File

@ -23,13 +23,13 @@ class X86LinkingContext;
template <class ELFT> class X86TargetLayout : public TargetLayout<ELFT> {
public:
X86TargetLayout(X86LinkingContext &context) : TargetLayout<ELFT>(context) {}
X86TargetLayout(X86LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
};
class X86TargetHandler final
: public DefaultTargetHandler<X86ELFType> {
public:
X86TargetHandler(X86LinkingContext &context);
X86TargetHandler(X86LinkingContext &ctx);
X86TargetLayout<X86ELFType> &getTargetLayout() override {
return *(_x86TargetLayout.get());
@ -42,18 +42,18 @@ public:
}
std::unique_ptr<Reader> getObjReader() override {
return llvm::make_unique<X86ELFObjectReader>(_x86LinkingContext);
return llvm::make_unique<X86ELFObjectReader>(_ctx);
}
std::unique_ptr<Reader> getDSOReader() override {
return llvm::make_unique<X86ELFDSOReader>(_x86LinkingContext);
return llvm::make_unique<X86ELFDSOReader>(_ctx);
}
std::unique_ptr<Writer> getWriter() override;
protected:
static const Registry::KindStrings kindStrings[];
X86LinkingContext &_x86LinkingContext;
X86LinkingContext &_ctx;
std::unique_ptr<X86TargetLayout<X86ELFType>> _x86TargetLayout;
std::unique_ptr<X86TargetRelocationHandler> _x86RelocationHandler;
};

6
lld/lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h
View File

@ -19,7 +19,7 @@ namespace elf {
class X86_64DynamicLibraryWriter : public DynamicLibraryWriter<X86_64ELFType> {
public:
X86_64DynamicLibraryWriter(X86_64LinkingContext &context,
X86_64DynamicLibraryWriter(X86_64LinkingContext &ctx,
X86_64TargetLayout &layout);
protected:
@ -45,8 +45,8 @@ private:
};
X86_64DynamicLibraryWriter::X86_64DynamicLibraryWriter(
X86_64LinkingContext &context, X86_64TargetLayout &layout)
: DynamicLibraryWriter(context, layout), _gotFile(new GOTFile(context)) {}
X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
: DynamicLibraryWriter(ctx, layout), _gotFile(new GOTFile(ctx)) {}
bool X86_64DynamicLibraryWriter::createImplicitFiles(
std::vector<std::unique_ptr<File>> &result) {

10
lld/lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h
View File

@ -18,10 +18,8 @@ namespace elf {
class X86_64ExecutableWriter : public ExecutableWriter<X86_64ELFType> {
public:
X86_64ExecutableWriter(X86_64LinkingContext &context,
X86_64TargetLayout &layout)
: ExecutableWriter(context, layout), _gotFile(new GOTFile(context)),
_context(context) {}
X86_64ExecutableWriter(X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
: ExecutableWriter(ctx, layout), _gotFile(new GOTFile(ctx)), _ctx(ctx) {}
protected:
// Add any runtime files and their atoms to the output
@ -30,7 +28,7 @@ protected:
ExecutableWriter::createImplicitFiles(result);
_gotFile->addAtom(*new (_gotFile->_alloc)
GLOBAL_OFFSET_TABLEAtom(*_gotFile));
if (_context.isDynamic())
if (_ctx.isDynamic())
_gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
result.push_back(std::move(_gotFile));
return true;
@ -52,7 +50,7 @@ private:
};
std::unique_ptr<GOTFile> _gotFile;
X86_64LinkingContext &_context;
X86_64LinkingContext &_ctx;
};
} // namespace elf

10
lld/lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp
View File

@ -16,8 +16,8 @@
using namespace lld;
using namespace elf;
X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &context)
: _context(context), _x86_64TargetLayout(new X86_64TargetLayout(context)),
X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &ctx)
: _ctx(ctx), _x86_64TargetLayout(new X86_64TargetLayout(ctx)),
_x86_64RelocationHandler(
new X86_64TargetRelocationHandler(*_x86_64TargetLayout.get())) {}
@ -27,13 +27,13 @@ void X86_64TargetHandler::registerRelocationNames(Registry &registry) {
}
std::unique_ptr<Writer> X86_64TargetHandler::getWriter() {
switch (this->_context.getOutputELFType()) {
switch (this->_ctx.getOutputELFType()) {
case llvm::ELF::ET_EXEC:
return llvm::make_unique<X86_64ExecutableWriter>(
_context, *_x86_64TargetLayout.get());
_ctx, *_x86_64TargetLayout.get());
case llvm::ELF::ET_DYN:
return llvm::make_unique<X86_64DynamicLibraryWriter>(
_context, *_x86_64TargetLayout.get());
_ctx, *_x86_64TargetLayout.get());
case llvm::ELF::ET_REL:
llvm_unreachable("TODO: support -r mode");
default:

11
lld/lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h
View File

@ -22,8 +22,7 @@ namespace lld {
namespace elf {
class X86_64TargetLayout : public TargetLayout<X86_64ELFType> {
public:
X86_64TargetLayout(X86_64LinkingContext &context)
: TargetLayout(context) {}
X86_64TargetLayout(X86_64LinkingContext &ctx) : TargetLayout(ctx) {}
void finalizeOutputSectionLayout() override {
sortOutputSectionByPriority(".init_array", ".init_array");
@ -34,7 +33,7 @@ public:
class X86_64TargetHandler
: public DefaultTargetHandler<X86_64ELFType> {
public:
X86_64TargetHandler(X86_64LinkingContext &context);
X86_64TargetHandler(X86_64LinkingContext &ctx);
X86_64TargetLayout &getTargetLayout() override {
return *(_x86_64TargetLayout.get());
@ -47,18 +46,18 @@ public:
}
std::unique_ptr<Reader> getObjReader() override {
return llvm::make_unique<X86_64ELFObjectReader>(_context);
return llvm::make_unique<X86_64ELFObjectReader>(_ctx);
}
std::unique_ptr<Reader> getDSOReader() override {
return llvm::make_unique<X86_64ELFDSOReader>(_context);
return llvm::make_unique<X86_64ELFDSOReader>(_ctx);
}
std::unique_ptr<Writer> getWriter() override;
protected:
static const Registry::KindStrings kindStrings[];
X86_64LinkingContext &_context;
X86_64LinkingContext &_ctx;
std::unique_ptr<X86_64TargetLayout> _x86_64TargetLayout;
std::unique_ptr<X86_64TargetRelocationHandler> _x86_64RelocationHandler;
};