Rename instances of ELFLinkingContext "ctx" instead of "context"

[ruiu]

Summary

Looks like MIPS uses "ctx" but for other architectures "context" is used.
I think "ctx" is preferred because it's shorter and is used often.

[Bigcheese]

lgtm

[Eugene.Zelenko]

Committed in r233344.

lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

 #include "DynamicLibraryWriter.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT>
 class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
-  AArch64DynamicLibraryWriter(AArch64LinkingContext &context,
+  AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
                               AArch64TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues() {
     return DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   virtual void addDefaultAtoms() {
     return DynamicLibraryWriter<ELFT>::addDefaultAtoms();
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   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(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h

 #include "ExecutableWriter.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT>
 class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
 public:
-  AArch64ExecutableWriter(AArch64LinkingContext &context,
+  AArch64ExecutableWriter(AArch64LinkingContext &ctx,
                           AArch64TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override {
     return ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   void addDefaultAtoms() override{
     return ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   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;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h

 #include "lld/Core/Simple.h"
 
 namespace lld {
 namespace elf {
 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());
   }
 
   void registerRelocationNames(Registry &registry) override;
 
   const AArch64TargetRelocationHandler &getRelocationHandler() const override {
     return *(_AArch64RelocationHandler.get());
   }
 
   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;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp

 #include "AArch64DynamicLibraryWriter.h"
 #include "AArch64ExecutableWriter.h"
 #include "AArch64LinkingContext.h"
 #include "AArch64TargetHandler.h"
 
 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) {
   registry.addKindTable(Reference::KindNamespace::ELF,
                         Reference::KindArch::AArch64, kindStrings);
 }
 
 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:
     llvm_unreachable("unsupported output type");
   }
 }
 
 #define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
 
 const Registry::KindStrings AArch64TargetHandler::kindStrings[] = {
 #include "llvm/Support/ELFRelocs/AArch64.def"
     LLD_KIND_STRING_END
 };
 
 #undef ELF_RELOC

lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h

 }
 
 namespace lld {
 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
   bool createImplicitFiles(std::vector<std::unique_ptr<File>> &) override;
 
   void finalizeDefaultAtomValues() override;
 
   void addDefaultAtoms() override {
     ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
   /// \brief Create symbol table.
   unique_bump_ptr<SymbolTable<ELFT>> createSymbolTable() override;
 
   void processUndefinedSymbol(StringRef symName,
                               RuntimeFile<ELFT> &file) const override;
 
   // Setup the ELF header.
   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(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   return true;
 }
 
void ARMExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   }
   // TODO: resolve addresses of __exidx_start/_end atoms
 }
 
 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>
 void ARMExecutableWriter<ELFT>::processUndefinedSymbol(
     StringRef symName, RuntimeFile<ELFT> &file) const {
   if (symName == gotSymbol) {
     file.addAbsoluteAtom(gotSymbol);
   } else if (symName.startswith("__exidx")) {
     file.addAbsoluteAtom("__exidx_start");
     file.addAbsoluteAtom("__exidx_end");
   }
 }
 
 template <class ELFT>
 std::error_code ARMExecutableWriter<ELFT>::setELFHeader() {
   if (std::error_code ec = ExecutableWriter<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)
       this->_elfHeader->e_entry(al->_virtualAddr | 0x1);
   }
 
   return std::error_code();
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_EXECUTABLE_WRITER_H

lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h

 namespace elf {
 
 /// \brief The SymbolTable class represents the symbol table in a ELF file
 template<class ELFT>
 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>
 void ARMSymbolTable<ELFT>::addDefinedAtom(Elf_Sym &sym, const DefinedAtom *da,
                                           int64_t addr) {
   SymbolTable<ELFT>::addDefinedAtom(sym, da, addr);
 
   // Set zero bit to distinguish real symbols addressing Thumb instructions.

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h

 
 namespace lld {
 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, false> ARMELFType;
 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())
       return *_tpOff;
 
     for (const auto &phdr : *this->_programHeader) {
       if (phdr->p_type == llvm::ELF::PT_TLS) {
         _tpOff = llvm::RoundUpToAlignment(TCB_SIZE, phdr->p_align);
         return *_tpOff;
       }
     }
     llvm_unreachable("TLS segment not found");
   }
 
 private:
   // TCB block size of the TLS.
   enum { TCB_SIZE = 0x8 };
 
   // Cached value of the TLS offset from the $tp pointer.
   llvm::Optional<uint64_t> _tpOff;
 };
 
 class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
 public:
-  ARMTargetHandler(ARMLinkingContext &context);
+  ARMTargetHandler(ARMLinkingContext &ctx);
 
   ARMTargetLayout<ARMELFType> &getTargetLayout() override {
     return *(_armTargetLayout.get());
   }
 
   void registerRelocationNames(Registry &registry) override;
 
   const ARMTargetRelocationHandler &getRelocationHandler() const override {
     return *(_armRelocationHandler.get());
   }
 
   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;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif // LLD_READER_WRITER_ELF_ARM_ARM_TARGET_HANDLER_H

lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp

 #include "Atoms.h"
 #include "ARMExecutableWriter.h"
 #include "ARMTargetHandler.h"
 #include "ARMLinkingContext.h"
 
 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,
                         kindStrings);
 }
 
 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");
   }
 }
 
 #define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
 
 const Registry::KindStrings ARMTargetHandler::kindStrings[] = {
 #include "llvm/Support/ELFRelocs/ARM.def"
     LLD_KIND_STRING_END
 };

lib/ReaderWriter/ELF/Chunk.h

enum Kind : uint8_t{ ELFHeader,     ///< ELF Header
                        ELFSegment,    ///< Segment
                        ELFSection,    ///< Section
                        AtomSection,   ///< A section containing atoms.
                        Expression     ///< A linker script expression
   };
   /// \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; }
   // Kind of chunk
   Kind kind() const { return _kind; }
   virtual uint64_t fileSize() const { return _fsize; }
   virtual void setFileSize(uint64_t sz) { _fsize = sz; }
   virtual void setAlign(uint64_t align) { _alignment = align; }
protected:
   Kind _kind;
   uint64_t _fsize;
   uint64_t _msize;
   uint64_t _alignment;
   uint32_t _order;
   uint64_t _ordinal;
   uint64_t _start;
   uint64_t _fileoffset;
-  const ELFLinkingContext &_context;
+  const ELFLinkingContext &_ctx;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/DefaultLayout.h

struct FindByName {
     FindByName(StringRef name) : _name(name) {}
     bool operator()(const lld::AtomLayout *j) { return j->_atom->name() == _name; }
   };
 
   typedef typename std::vector<lld::AtomLayout *>::iterator AbsoluteAtomIterT;
 
   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,
                                int32_t contentPermissions) override;
 
   /// \brief Return the name of the input section by decoding the input
   /// sectionChoice.
   virtual StringRef getInputSectionName(const DefinedAtom *da) const;
public:
 
   bool hasPLTRelocationTable() const { return !!_pltRelocationTable; }
 
   /// \brief Get or create the dynamic relocation table. All relocations in this
   /// table are processed at startup.
   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());
     }
     return _dynamicRelocationTable.get();
   }
 
   /// \brief Get or create the PLT relocation table. Referenced by DT_JMPREL.
   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());
     }
     return _pltRelocationTable.get();
   }
 
   uint64_t getTLSSize() const {
     for (const auto &phdr : *_programHeader)
virtual AtomSection<ELFT> *createSection(
       StringRef name, int32_t contentType,
       DefinedAtom::ContentPermissions contentPermissions,
       SectionOrder sectionOrder);
 
   /// \brief Create a new relocation table.
   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:
   /// Helper function that returns the priority value from an input section.
   uint32_t getPriorityFromSectionName(StringRef sectionName) const;
 
 protected:
   llvm::BumpPtrAllocator _allocator;
   SectionMapT _sectionMap;
   OutputSectionMapT _outputSectionMap;
   AdditionalSegmentMapT _additionalSegmentMap;
   SegmentMapT _segmentMap;
   std::vector<Chunk<ELFT> *> _sections;
   std::vector<Segment<ELFT> *> _segments;
   std::vector<OutputSection<ELFT> *> _outputSections;
   ELFHeader<ELFT> *_elfHeader;
   ProgramHeader<ELFT> *_programHeader;
   unique_bump_ptr<RelocationTable<ELFT>> _dynamicRelocationTable;
   unique_bump_ptr<RelocationTable<ELFT>> _pltRelocationTable;
   std::vector<lld::AtomLayout *> _absoluteAtoms;
   AtomSetT _referencedDynAtoms;
   llvm::StringSet<> _copiedDynSymNames;
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   script::Sema &_linkerScriptSema;
 };
 
 template <class ELFT>
 Layout::SectionOrder DefaultLayout<ELFT>::getSectionOrder(
     StringRef name, int32_t contentType, int32_t contentPermissions) {
   switch (contentType) {
   case DefinedAtom::typeResolver:
default:
     return section->hasOutputSegment();
   }
 }
 
 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);
 }
 
 template <class ELFT>
 AtomSection<ELFT> *
 DefaultLayout<ELFT>::getSection(StringRef sectionName, int32_t contentType,
                                 DefinedAtom::ContentPermissions permissions,
                                 const DefinedAtom *da) {
if (const DefinedAtom *definedAtom = dyn_cast<DefinedAtom>(atom)) {
 
     StringRef sectionName = getInputSectionName(definedAtom);
     AtomSection<ELFT> *section =
         getSection(sectionName, contentType, permissions, definedAtom);
 
     // 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;
       }
 
       if (!reloc->target())
         continue;
 
       //Ignore undefined atoms that are not target of dynamic relocations
       if (isa<UndefinedAtom>(reloc->target()) && isLocalReloc)
         continue;
 
-      if (_context.isCopyRelocation(*reloc)) {
+      if (_ctx.isCopyRelocation(*reloc)) {
         _copiedDynSymNames.insert(definedAtom->name());
         continue;
       }
 
       _referencedDynAtoms.insert(reloc->target());
     }
 
     return section->appendAtom(atom);
std::sort(sections.begin(), sections.end(),
               }
               return getPriorityFromSectionName(lhsSectionName) <
                      getPriorityFromSectionName(rhsSectionName);
             });
 }
 
 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();
 
   // Create output sections.
   createOutputSections();
 
   // Finalize output section layout.
   finalizeOutputSectionLayout();
for (auto ai : osi->sections()) {
         int64_t segmentType = getSegmentType(section);
 
         osi->setHasSegment();
         section->setSegmentType(segmentType);
         StringRef segmentName = section->segmentKindToStr();
 
         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
         lookupSectionFlag &= ~(llvm::ELF::SHF_STRINGS | llvm::ELF::SHF_MERGE);
 
         // Merge the TLS section into the DATA segment itself
         lookupSectionFlag &= ~(llvm::ELF::SHF_TLS);
 
         Segment<ELFT> *segment;
         // We need a separate segment for sections that don't have
         // the segment type to be PT_LOAD
         if (segmentType != llvm::ELF::PT_LOAD) {
           const AdditionalSegmentKey key(segmentType, lookupSectionFlag);
           const std::pair<AdditionalSegmentKey, Segment<ELFT> *>
           additionalSegment(key, nullptr);
           std::pair<typename AdditionalSegmentMapT::iterator, bool>
           additionalSegmentInsert(
               _additionalSegmentMap.insert(additionalSegment));
           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);
           }
           segment->append(section);
         }
         if (segmentType == llvm::ELF::PT_NULL)
           continue;
 
for (auto ai : osi->sections()) {
         const std::pair<SegmentKey, Segment<ELFT> *> currentSegment(key,
                                                                     nullptr);
         std::pair<typename SegmentMapT::iterator, bool> segmentInsert(
             _segmentMap.insert(currentSegment));
         if (!segmentInsert.second) {
           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);
         }
         // Insert chunks with linker script expressions that occur at this
         // point, just before appending a new input section
         addExtraChunksToSegment(segment, section->archivePath(),
                                 section->memberPath(),
                                 section->inputSectionName());
         segment->append(section);
       }
     }
   }
-  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);
   }
 }
 
 template<class ELFT>
 void
 DefaultLayout<ELFT>::assignVirtualAddress() {
   if (_segments.empty())
     return;
 
   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
   // so that AT_PHDR is set correctly by the loader and so they are accessible
   // at runtime. To do this we simply prepend them to the first loadable Segment
   // and let the layout logic take care of it.
   Segment<ELFT> *firstLoadSegment = nullptr;
   for (auto si : _segments) {
void DefaultLayout<ELFT>::addExtraChunksToSegment(Segment<ELFT> *segment,
                                                   StringRef sectionName) {
   if (!_linkerScriptSema.hasLayoutCommands())
     return;
 
   std::vector<const script::SymbolAssignment *> exprs =
       _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);
   }
 }
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/DynamicLibraryWriter.h

 class DynamicLibraryWriter;
 
 //===----------------------------------------------------------------------===//
 //  DynamicLibraryWriter Class
 //===----------------------------------------------------------------------===//
 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);
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
 
 protected:

lib/ReaderWriter/ELF/ELFFile.h

 /// \brief All atoms are owned by a File. To add linker specific atoms
 /// the atoms need to be inserted to a file called (RuntimeFile) which
 /// are basically additional symbols required by libc and other runtime
 /// libraries part of executing a program. This class provides support
 /// for adding absolute symbols and undefined symbols
 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) {
     assert(!symbolName.empty() && "AbsoluteAtoms must have a name");
     Elf_Sym *symbol = new (this->_readerStorage) Elf_Sym;
     symbol->st_name = 0;
     symbol->st_value = 0;
     symbol->st_shndx = llvm::ELF::SHN_ABS;

lib/ReaderWriter/ELF/ExecutableWriter.h

 class ExecutableWriter;
 
 //===----------------------------------------------------------------------===//
 //  ExecutableWriter Class
 //===----------------------------------------------------------------------===//
 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);
   virtual void addDefaultAtoms();
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File> > &);
   virtual void finalizeDefaultAtomValues();
   virtual void createDefaultSections();
 

 void ExecutableWriter<ELFT>::buildDynamicSymbolTable(const File &file) {
   for (auto sec : this->_layout.sections())
     if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
       for (const auto &atom : section->atoms()) {
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         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(),
                                              atom->_virtualAddr, atom);
       }
 
   // 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)
         this->_dynamicSymbolTable->addSymbol(a, ELF::SHN_UNDEF);
     }
   }
 
   OutputELFWriter<ELFT>::buildDynamicSymbolTable(file);
 }
 
 /// \brief Add absolute symbols by default. These are linker added
 /// absolute symbols
 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");
   _runtimeFile->addAbsoluteAtom("end");
   _runtimeFile->addAbsoluteAtom("__preinit_array_start");
   _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 {
     _runtimeFile->addAbsoluteAtom("__rel_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rel_iplt_end");
   }
   _runtimeFile->addAbsoluteAtom("__fini_array_start");
   _runtimeFile->addAbsoluteAtom("__fini_array_end");
 }
 
 /// \brief Hook in lld to add CRuntime file
 template <class ELFT>
 bool ExecutableWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File> > &result) {
   // Add the default atoms as defined by executables
   ExecutableWriter<ELFT>::addDefaultAtoms();
   OutputELFWriter<ELFT>::createImplicitFiles(result);
   result.push_back(std::move(_runtimeFile));
   return true;
 }
 
 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());
   }
 }
 
 /// Finalize the value of all the absolute symbols that we
 /// created
 template <class ELFT> void ExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   OutputELFWriter<ELFT>::finalizeDefaultAtomValues();
auto startEnd = [&](StringRef sym, StringRef sec) -> void {
     } else {
       (*s)->_virtualAddr = 0;
       (*e)->_virtualAddr = 0;
     }
   };
 
   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");
   startEnd("fini_array", ".fini_array");
 
   assert(!(bssStartAtomIter == this->_layout.absoluteAtoms().end() ||
            bssEndAtomIter == this->_layout.absoluteAtoms().end() ||
            underScoreEndAtomIter == this->_layout.absoluteAtoms().end() ||

lib/ReaderWriter/ELF/HeaderChunks.h

public:
 
   void finalize() {
     _eh.e_ident[llvm::ELF::EI_CLASS] =
         (ELFT::Is64Bits) ? llvm::ELF::ELFCLASS64 : llvm::ELF::ELFCLASS32;
     _eh.e_ident[llvm::ELF::EI_DATA] =
         (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:
   Elf_Ehdr _eh;
 };
 
 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);
   memset(_eh.e_ident, 0, llvm::ELF::EI_NIDENT);
   e_ident(llvm::ELF::EI_MAG0, 0x7f);
   e_ident(llvm::ELF::EI_MAG1, 'E');
   e_ident(llvm::ELF::EI_MAG2, 'L');
   e_ident(llvm::ELF::EI_MAG3, 'F');
bool operator()(const llvm::object::Elf_Phdr_Impl<ELFT> *j) const {
               (!(j->p_flags & _flagsClear)));
     }
   private:
     uint64_t _type;
     uint64_t _flags;
     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();
   }
 
   bool addSegment(Segment<ELFT> *segment);
 
   void resetProgramHeaders() { _phi = _ph.begin(); }
 
private:
   std::vector<Elf_Phdr *> _ph;
   PhIterT _phi;
   llvm::BumpPtrAllocator _allocator;
 };
 
 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
   if (segment->segmentType() != llvm::ELF::PT_LOAD) {
     Elf_Phdr *phdr = allocateProgramHeader(allocatedNew);
     phdr->p_type = segment->segmentType();
     phdr->p_offset = segment->fileOffset();
     phdr->p_vaddr = segment->virtualAddr();

 
 private:
   StringTable<ELFT> *_stringSection;
   std::vector<Elf_Shdr*>                  _sectionInfo;
   llvm::BumpPtrAllocator                  _sectionAllocate;
 };
 
 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);
   // The first element in the list is always NULL
   Elf_Shdr *nullshdr = new (_sectionAllocate.Allocate<Elf_Shdr>()) Elf_Shdr;
   ::memset(nullshdr, 0, sizeof (Elf_Shdr));
   _sectionInfo.push_back(nullshdr);
   this->_fsize += sizeof (Elf_Shdr);

lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h

 namespace elf {
 
 template <typename ELFT> class HexagonTargetLayout;
 
 template <class ELFT>
 class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT>,
                                     public HexagonELFWriter<ELFT> {
 public:
-  HexagonDynamicLibraryWriter(HexagonLinkingContext &context,
+  HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
                               HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues();
 
   virtual std::error_code setELFHeader() {
     DynamicLibraryWriter<ELFT>::setELFHeader();
     HexagonELFWriter<ELFT>::setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 private:
   void addDefaultAtoms() {
     _hexagonRuntimeFile->addAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
     _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(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_hexagonRuntimeFile));

lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h

 
 namespace lld {
 namespace elf {
 
 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) {
     elfHeader.e_ident(llvm::ELF::EI_VERSION, 1);
     elfHeader.e_ident(llvm::ELF::EI_OSABI, 0);
     elfHeader.e_version(1);
     elfHeader.e_flags(0x3);
     return true;
   }
 
   void finalizeHexagonRuntimeAtomValues() {
-    if (_hexagonLinkingContext.isDynamic()) {
+    if (_ctx.isDynamic()) {
       auto gotAtomIter =
           _hexagonTargetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
       auto gotpltSection = _hexagonTargetLayout.findOutputSection(".got.plt");
       if (gotpltSection)
         (*gotAtomIter)->_virtualAddr = gotpltSection->virtualAddr();
       else
         (*gotAtomIter)->_virtualAddr = 0;
       auto dynamicAtomIter = _hexagonTargetLayout.findAbsoluteAtom("_DYNAMIC");
       auto dynamicSection = _hexagonTargetLayout.findOutputSection(".dynamic");
       if (dynamicSection)
         (*dynamicAtomIter)->_virtualAddr = dynamicSection->virtualAddr();
       else
         (*dynamicAtomIter)->_virtualAddr = 0;
     }
   }
 
 private:
-  HexagonLinkingContext &_hexagonLinkingContext;
+  HexagonLinkingContext &_ctx;
   HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
 };
 
 } // elf
 } // lld
 #endif // HEXAGON_ELF_WRITERS_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h

 namespace lld {
 namespace elf {
 typedef llvm::object::ELFType<llvm::support::little, 2, false> HexagonELFType;
 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
 
 #endif // LLD_READER_WRITER_ELF_HEXAGON_HEXAGON_EXECUTABLE_ATOM_H

lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h

 namespace elf {
 
 template <typename ELFT> class HexagonTargetLayout;
 
 template <class ELFT>
 class HexagonExecutableWriter : public ExecutableWriter<ELFT>,
                                 public HexagonELFWriter<ELFT> {
 public:
-  HexagonExecutableWriter(HexagonLinkingContext &context,
+  HexagonExecutableWriter(HexagonLinkingContext &ctx,
                           HexagonTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues();
 
   virtual std::error_code setELFHeader() {
     ExecutableWriter<ELFT>::setELFHeader();
     HexagonELFWriter<ELFT>::setELFHeader(*this->_elfHeader);
     return std::error_code();
   }
 
 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(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   // Add the default atoms as defined for hexagon
   addDefaultAtoms();
   result.push_back(std::move(_hexagonRuntimeFile));

lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h

 namespace elf {
 template <typename ELFT> class HexagonTargetLayout;
 class HexagonLinkingContext;
 
 /// \brief Handle Hexagon SData section
 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;
     this->_alignment = 4096;
   }
 
   /// \brief Finalize the section contents before writing
   virtual void doPreFlight();

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h

const HexagonTargetRelocationHandler &getRelocationHandler() const override {
     return *(_hexagonRelocationHandler.get());
   }
 
   HexagonTargetLayout<HexagonELFType> &getTargetLayout() override {
     return *(_hexagonTargetLayout.get());
   }
 
   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;
 
 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;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

 #include "HexagonTargetHandler.h"
 
 using namespace lld;
 using namespace elf;
 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:
     llvm_unreachable("unsupported output type");
   }
 }
 
 using namespace llvm::ELF;

lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h

void MipsDynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }
 
 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
 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
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h

: ExecutableWriter<ELFT>(ctx, layout), _writeHelper(ctx, layout),
       _mipsTargetLayout(layout) {}
 
 template <class ELFT>
 std::error_code MipsExecutableWriter<ELFT>::setELFHeader() {
   std::error_code ec = ExecutableWriter<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 ||
         ea->codeModel() == DefinedAtom::codeMipsMicroPIC)
       // Adjust entry symbol value if this symbol is microMIPS encoded.
       this->_elfHeader->e_entry(al->_virtualAddr | 1);
   }
 
if (auto section = dyn_cast<AtomSection<ELFT>>(sec))
           continue;
         }
 
         const DefinedAtom *da = dyn_cast<const DefinedAtom>(atom->_atom);
         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(),
                                              atom->_virtualAddr, atom);
       }
 
   for (const UndefinedAtom *a : file.undefined())
void MipsExecutableWriter<ELFT>::finalizeDefaultAtomValues() {
   // Finalize the atom values that are part of the parent.
   ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   _writeHelper.finalizeMipsRuntimeAtomValues();
 }
 
 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
 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
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h

 template <class ELFT> class MipsRelocationTable : public RelocationTable<ELFT> {
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
 
   static const bool _isMips64EL =
       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,
                  const Reference &ref) override {
     uint32_t rType = ref.kindValue() | (ref.tag() << 8);
     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;
   }
 
   void writeRel(ELFWriter *writer, Elf_Rel &r, const DefinedAtom &atom,
                 const Reference &ref) override {
     uint32_t rType = ref.kindValue() | (ref.tag() << 8);

lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h

Layout::SectionOrder getSectionOrder(StringRef name, int32_t contentType,
 
     return DefaultLayout<ELFT>::getSectionOrder(name, contentType,
                                                 contentPermissions);
   }
 
 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:
   MipsGOTSection<ELFT> *_gotSection;
   MipsPLTSection<ELFT> *_pltSection;
   llvm::Optional<AtomLayout *> _gpAtom;
   llvm::Optional<AtomLayout *> _gpDispAtom;
 };

lib/ReaderWriter/ELF/OutputELFWriter.h

 template <class ELFT> class OutputELFWriter;
 template <class ELFT> class TargetLayout;
 
 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);
     if (a) _atomsAdded = true;
     return a;
   }
 
   Atom *addUndefinedAtom(StringRef) override {
     llvm_unreachable("Cannot add undefined atoms to resolve undefined symbols");
   }
 
   bool hasAtoms() const { return _atomsAdded; }
 
 private:
   bool _atomsAdded;
 };
 
 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);
     // If atoms were added - release the file to the caller.
     return _file->hasAtoms() ? _file.release() : nullptr;
   }
 
 private:
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   Resolver _resolver;
 
   // The allocator should go before bump pointers because of
   // reversed destruction order.
   llvm::BumpPtrAllocator _alloc;
   unique_bump_ptr<SymbolFile<ELFT>> _file;
 };
 
 } // end anon namespace
 
 //===----------------------------------------------------------------------===//
 //  OutputELFWriter Class
 //===----------------------------------------------------------------------===//
 /// \brief This acts as the base class for all the ELF writers that are output
 /// for emitting an ELF output file. This class also acts as a common class for
 /// creating static and dynamic executables. All the function in this class
 /// can be overridden and an appropriate writer be created
 template<class ELFT>
 class OutputELFWriter : public ELFWriter {
 public:
   typedef Elf_Shdr_Impl<ELFT> Elf_Shdr;
   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
   virtual void createDefaultSections();
 
   // Build all the output sections
   void buildChunks(const File &file) override;
 
protected:
   }
 
   /// \brief Process undefined symbols that left after resolution step.
   virtual void processUndefinedSymbol(StringRef symName,
                                       RuntimeFile<ELFT> &file) const {}
 
   llvm::BumpPtrAllocator _alloc;
 
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   TargetHandler<ELFT> &_targetHandler;
 
   typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
   AtomToAddress _atomToAddressMap;
   TargetLayout<ELFT> &_layout;
   unique_bump_ptr<ELFHeader<ELFT>> _elfHeader;
   unique_bump_ptr<ProgramHeader<ELFT>> _programHeader;
   unique_bump_ptr<SymbolTable<ELFT>> _symtab;

 private:
   static StringRef maybeGetSOName(Node *node);
 };
 
 //===----------------------------------------------------------------------===//
 //  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) {
   ScopedTask task(getDefaultDomain(), "buildChunks");
   for (const DefinedAtom *definedAtom : file.defined()) {
     DefinedAtom::ContentType contentType = definedAtom->contentType();
     // Dont add COMDAT group atoms and GNU linkonce atoms, as they are used for
     // symbol resolution.
for (const auto &sla : file.sharedLibrary()) {
     if (isDynSymEntryRequired(sla)) {
       _dynamicSymbolTable->addSymbol(sla, ELF::SHN_UNDEF);
       _soNeeded.insert(sla->loadName());
       continue;
     }
     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(), ":"));
     Elf_Dyn dyn;
     dyn.d_tag = DT_RPATH;
     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);
     _dynamicTable->addEntry(dyn);
   }
   // The dynamic symbol table need to be sorted earlier because the hash
   // table needs to be built using the dynamic symbol table. It would be
   // late to sort the symbols due to that in finalize. In the dynamic symbol
void OutputELFWriter<ELFT>::assignSectionsWithNoSegments() {
   for (auto sec : _layout.sections())
     if (auto section = dyn_cast<Section<ELFT>>(sec))
       if (!DefaultLayout<ELFT>::hasOutputSegment(section))
         _shdrtab->updateSection(section);
 }
 
 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());
 }
 
 template <class ELFT>
 bool OutputELFWriter<ELFT>::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   // Add the virtual archive to resolve undefined symbols.
   // The file will be added later in the linking context.
   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
   result.push_back(std::move(_scriptFile));
   return true;
 }
 
 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());
   _shdrtab->setStringSection(_shstrtab.get());
   _symtab->setStringSection(_strtab.get());
   _layout.addSection(_shdrtab.get());
 
   for (auto sec : _layout.sections()) {
     // TODO: use findOutputSection
     auto section = dyn_cast<Section<ELFT>>(sec);
     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());
     _hashTable->setSymbolTable(_dynamicSymbolTable.get());
     _layout.addSection(_dynamicTable.get());
     _layout.addSection(_dynamicStringTable.get());
     _layout.addSection(_dynamicSymbolTable.get());
     _layout.addSection(_hashTable.get());
     _dynamicSymbolTable->setStringSection(_dynamicStringTable.get());
     _dynamicTable->setSymbolTable(_dynamicSymbolTable.get());
     _dynamicTable->setHashTable(_hashTable.get());
     if (_layout.hasDynamicRelocationTable())
       _layout.getDynamicRelocationTable()->setSymbolTable(
           _dynamicSymbolTable.get());
     if (_layout.hasPLTRelocationTable())
       _layout.getPLTRelocationTable()->setSymbolTable(
           _dynamicSymbolTable.get());
   }
 }
 
 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
 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",
+      new (_alloc)
+          DynamicSymbolTable<ELFT>(this->_ctx, _layout, ".dynsym",
                                    DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
 }
 
 template <class ELFT>
 std::error_code OutputELFWriter<ELFT>::buildOutput(const File &file) {
   ScopedTask buildTask(getDefaultDomain(), "ELF Writer buildOutput");
   buildChunks(file);
 
   // Create the default sections like the symbol table, string table, and the
   // section string table
   createDefaultSections();
 
   // Set the Layout
   _layout.assignSectionsToSegments();
 
   // Create the dynamic table entries
-  if (_context.isDynamic()) {
+  if (_ctx.isDynamic()) {
     _dynamicTable->createDefaultEntries();
     buildDynamicSymbolTable(file);
   }
 
   // Call the preFlight callbacks to modify the sections and the atoms
   // contained in them, in anyway the targets may want
   _layout.doPreFlight();
 
   _layout.assignVirtualAddress();
 
   // Finalize the default value of symbols that the linker adds
   finalizeDefaultAtomValues();
 
   // Build the Atom To Address map for applying relocations
   buildAtomToAddressMap(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
   _layout.finalize();
 
   // build Section Header table
   buildSectionHeaderTable();
 
   // assign Offsets and virtual addresses
   // 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);
   _elfHeader->e_phoff(_programHeader->fileOffset());
   _elfHeader->e_shoff(_shdrtab->fileOffset());
   _elfHeader->e_phentsize(_programHeader->entsize());
   _elfHeader->e_phnum(_programHeader->numHeaders());
   _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);
 
   return std::error_code();
 }
 
 template <class ELFT> uint64_t OutputELFWriter<ELFT>::outputFileSize() const {

lib/ReaderWriter/ELF/SectionChunks.h

 namespace elf {
 template <class> class OutputSection;
 using namespace llvm::ELF;
 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) {}
 
   /// \brief Modify the section contents before assigning virtual addresses
   //  or assigning file offsets
   void doPreFlight() override {}
 
protected:
   StringRef _outputSectionName;
   StringRef _archivePath;
   StringRef _memberPath;
 };
 
 /// \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) {
     this->setOrder(order);
 
     switch (contentType) {
     case DefinedAtom::typeCode:
     case DefinedAtom::typeDataFast:
protected:
   int32_t _contentPermissions;
   bool _isLoadedInMemory;
   std::vector<lld::AtomLayout *> _atoms;
   mutable std::mutex _outputMutex;
 
   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";
     }
 
     std::string errStr = (Twine(errorStr) + " in file " +
                           atom._atom->file().path() +
                           ": reference from " + atom._atom->name() +
                           "+" + Twine(ref.offsetInAtom()) +
                           " to " + ref.target()->name() +
parallel_for_each(_atoms.begin(), _atoms.end(), [&](lld::AtomLayout * ai) {
     // Copy raw content of atom to file buffer.
     ArrayRef<uint8_t> content = definedAtom->rawContent();
     uint64_t contentSize = content.size();
     if (contentSize == 0)
       return;
     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)) {
         printError(ec.message(), *ai, *ref);
         success = false;
       }
     }
   });
private:
   };
   typedef typename llvm::DenseMap<StringRef, uint64_t,
                                   StringRefMappingInfo> StringMapT;
   typedef typename StringMapT::iterator StringMapTIter;
   StringMapT _stringMap;
 };
 
 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("");
   this->_fsize = 1;
   this->_alignment = 1;
   this->setOrder(order);
   this->_type = SHT_STRTAB;
   if (dynamic) {

 template<class ELFT>
 class SymbolTable : public Section<ELFT> {
   typedef typename llvm::object::ELFDataTypeTypedefHelper<ELFT>::Elf_Addr
       Elf_Addr;
 
 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
   void setNumEntries(int64_t numEntries) const {
     if (_stringSection)
       _stringSection->setNumEntries(numEntries);
   }
 
protected:
 
   llvm::BumpPtrAllocator _symbolAllocate;
   StringTable<ELFT> *_stringSection;
   std::vector<SymbolEntry> _symbolTable;
 };
 
 /// 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));
   _symbolTable.push_back(SymbolEntry(nullptr, symbol, nullptr));
   this->_entSize = sizeof(Elf_Sym);
   this->_fsize = sizeof(Elf_Sym);
   this->_alignment = sizeof(Elf_Addr);
   this->_type = SHT_SYMTAB;
for (const auto &sti : _symbolTable) {
     dest += sizeof(Elf_Sym);
   }
 }
 
 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;
     this->_msize = this->_fsize;
   }
 
   // Set the dynamic hash table for symbols to be added into
   void setHashTable(HashSection<ELFT> *hashTable) { _hashTable = hashTable; }
protected:
   TargetLayout<ELFT> &_layout;
 };
 
 template <class ELFT> class RelocationTable : public Section<ELFT> {
 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 {
       this->_entSize = sizeof(Elf_Rel);
       this->_type = SHT_REL;
     }
   }
 
if (this->_outputSection)
       this->_outputSection->setLink(this->_link);
   }
 
   void write(ELFWriter *writer, TargetLayout<ELFT> &layout,
              llvm::FileOutputBuffer &buffer) override {
     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",
                         llvm::dbgs()
                             << rel.second->kindValue() << " relocation at "
                             << rel.first->name() << "@" << r.r_offset << " to "
                             << rel.second->target()->name() << "@" << r.r_addend
                             << "\n";);

 protected:
   const DynamicSymbolTable<ELFT> *_symbolTable;
 
   virtual void writeRela(ELFWriter *writer, Elf_Rela &r,
                          const DefinedAtom &atom, const Reference &ref) {
     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;
   }
 
   virtual void writeRel(ELFWriter *writer, Elf_Rel &r, const DefinedAtom &atom,
                         const Reference &ref) {
     r.setSymbolAndType(getSymbolIndex(ref.target()), ref.kindValue(), false);

 
 template <class ELFT> class HashSection;
 
 template <class ELFT> class DynamicTable : public Section<ELFT> {
 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;
     // Reserve space for the DT_NULL entry.
     this->_fsize = sizeof(Elf_Dyn);
     this->_msize = sizeof(Elf_Dyn);
     this->_type = SHT_DYNAMIC;
     this->_flags = SHF_ALLOC;
void write(ELFWriter *writer, TargetLayout<ELFT> &layout,
     Elf_Dyn d;
     d.d_tag = 0;
     d.d_un.d_val = 0;
     _entries.push_back(d);
     std::memcpy(dest, _entries.data(), this->_fsize);
   }
 
   virtual void createDefaultEntries() {
-    bool isRela = this->_context.isRelaOutputFormat();
+    bool isRela = this->_ctx.isRelaOutputFormat();
 
     Elf_Dyn dyn;
     dyn.d_un.d_val = 0;
 
     dyn.d_tag = DT_HASH;
     _dt_hash = addEntry(dyn);
     dyn.d_tag = DT_STRTAB;
     _dt_strtab = addEntry(dyn);
private:
   std::size_t _dt_textrel;
   std::size_t _dt_init;
   std::size_t _dt_fini;
   TargetLayout<ELFT> &_layout;
   DynamicSymbolTable<ELFT> *_dynamicSymbolTable;
   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;
   }
 };
 
 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.
     this->_fsize = interp.size() + 1;
     this->_msize = this->_fsize;
     this->_type = SHT_PROGBITS;
     this->_flags = SHF_ALLOC;
   }

 
 template <class ELFT> class HashSection : public Section<ELFT> {
   struct SymbolTableEntry {
     StringRef _name;
     uint32_t _index;
   };
 
 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;
     this->_flags = SHF_ALLOC;
     this->_alignment = ELFT::Is64Bits ? 8 : 4;
     this->_fsize = 0;
     this->_msize = 0;
   }
private:
   std::vector<SymbolTableEntry> _entries;
   std::vector<uint32_t> _buckets;
   std::vector<uint32_t> _chains;
   const DynamicSymbolTable<ELFT> *_symbolTable;
 };
 
 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;
     this->_type = SHT_PROGBITS;
     this->_flags = SHF_ALLOC;
     this->_alignment = ELFT::Is64Bits ? 8 : 4;
     // Minimum size for empty .eh_frame_hdr.
     this->_fsize = 1 + 1 + 1 + 1 + 4;

lib/ReaderWriter/ELF/SegmentChunks.h

 //  the sections are already separated based on different flags and properties
 //  the segment is just a way to concatenate sections to segments
 template<class ELFT>
 class Segment : public Chunk<ELFT> {
 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
   enum SegmentOrder {
     permUnknown,
     permRWX,
     permRX,
     permR,
case llvm::ELF::PT_TLS:
       return Chunk<ELFT>::ContentType::TLS;
     case llvm::ELF::PT_NOTE:
       return Chunk<ELFT>::ContentType::Note;
     default:
       return Chunk<ELFT>::ContentType::Unknown;
     }
   }
 
-  int pageSize() const { return this->_context.getPageSize(); }
+  int pageSize() const { return this->_ctx.getPageSize(); }
 
   int rawflags() const { return _atomflags; }
 
   int64_t atomflags() const {
     switch (_atomflags) {
 
     case DefinedAtom::permUnknown:
       return permUnknown;
private:
   const script::SymbolAssignment *_expr;
   script::Sema &_linkerScriptSema;
 };
 
 /// \brief A Program Header segment contains a set of chunks instead of sections
 /// 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);
   }
 
   /// Finalize the segment, before we want to write the segment header
   /// information
   void finalize() {
     // If the segment is of type Program Header, then the values fileOffset
     // and the fileSize need to be picked up from the last section, the first
     // section points to the ELF header and the second chunk points to the
     // actual program headers
     this->setFileOffset(this->_sections.back()->fileOffset());
     this->setVirtualAddr(this->_sections.back()->virtualAddr());
     this->_fsize = this->_sections.back()->fileSize();
     this->_msize = this->_sections.back()->memSize();
   }
 
 };
 
 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.
 LLVM_ATTRIBUTE_UNUSED
 static DefinedAtom::ContentPermissions toAtomPerms(uint64_t flags) {
   switch (flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR)) {
   case SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR:
     return DefinedAtom::permRWX;
bool Segment<ELFT>::compareSegments(Segment<ELFT> *sega, Segment<ELFT> *segb) {
   return type1 < type2;
 }
 
 template <class ELFT>
 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);
   for (auto &slice : slices()) {
     bool isFirstSection = true;
     for (auto section : slice->sections()) {
       // Handle linker script expressions, which may change the offset
       if (!isFirstSection)
for (auto section : slice->sections()) {
           if (sect && sect->isLoadableSection() &&
               ((virtualAddress & (p_align - 1)) !=
                (fileOffset & (p_align - 1))))
             fileOffset = llvm::RoundUpToAlignment(fileOffset, p_align) +
                          (virtualAddress % p_align);
         }
       } else if (!isDataPageAlignedForNMagic && needAlign(section)) {
         fileOffset =
-            llvm::RoundUpToAlignment(fileOffset, this->_context.getPageSize());
+            llvm::RoundUpToAlignment(fileOffset, this->_ctx.getPageSize());
         isDataPageAlignedForNMagic = true;
       }
       if (isFirstSection) {
         slice->setFileOffset(fileOffset);
         isFirstSection = false;
         curSliceFileOffset = fileOffset;
       }
       section->setFileOffset(fileOffset);
template <class ELFT> void Segment<ELFT>::assignVirtualAddress(uint64_t addr) {
 
   startSectionIter = _sections.begin();
   startSection = 0;
   bool isFirstSection = true;
   bool isDataPageAlignedForNMagic = false;
   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) {
     // If this is first section in the segment, page align the section start
     // address. The linker needs to align the data section to a page boundary
     // only if NMAGIC is set.
     if (isFirstSection) {
       isFirstSection = false;
       if (alignSegments &&
           _outputMagic != ELFLinkingContext::OutputMagic::NMAGIC &&
           _outputMagic != ELFLinkingContext::OutputMagic::OMAGIC)
         // 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
       uint64_t newAddr = llvm::RoundUpToAlignment(startAddr, (*si)->alignment());
       // Handle linker script expressions, which *may update newAddr* if the
       // expression assigns to "."
       if (auto expr = dyn_cast<ExpressionChunk<ELFT>>(*si))
         expr->evalExpr(newAddr);
if (isFirstSection) {
       if ((*si)->order() != DefaultLayout<ELFT>::ORDER_TBSS)
         curSliceSize = (*si)->memSize();
     } else {
       uint64_t curAddr = curSliceAddress + curSliceSize;
       if (!isDataPageAlignedForNMagic && needAlign(*si)) {
         // 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());
       // Handle linker script expressions, which *may update newAddr* if the
       // expression assigns to "."
       if (auto expr = dyn_cast<ExpressionChunk<ELFT>>(*si))
         expr->evalExpr(newAddr);
       Section<ELFT> *sec = dyn_cast<Section<ELFT>>(*si);
if (isFirstSection) {
       }
       bool autoCreateSlice = true;
       if (curOutputSectionName == prevOutputSectionName)
         autoCreateSlice = false;
       // If the newAddress computed is more than a page away, let's create
       // 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 =
             std::find_if(_segmentSlices.begin(), _segmentSlices.end(),
                          [startSection](SegmentSlice<ELFT> *s) -> bool {
               return s->startSection() == startSection;
             });
         if (sliceIter == _segmentSlices.end()) {

lib/ReaderWriter/ELF/TargetLayout.h

 
 namespace lld {
 namespace elf {
 /// \brief The target can override certain functions in the DefaultLayout
 /// class so that the order, the name of the section and the segment type could
 /// 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
 
 #endif

lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h

 #include "X86LinkingContext.h"
 
 namespace lld {
 namespace elf {
 
 template <class ELFT>
 class X86DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
-  X86DynamicLibraryWriter(X86LinkingContext &context,
+  X86DynamicLibraryWriter(X86LinkingContext &ctx,
                           X86TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues() {
     return DynamicLibraryWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   virtual void addDefaultAtoms() {
     return DynamicLibraryWriter<ELFT>::addDefaultAtoms();
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   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(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter<ELFT>::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h

 #include "X86LinkingContext.h"
 
 namespace lld {
 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
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues() {
     return ExecutableWriter<ELFT>::finalizeDefaultAtomValues();
   }
 
   virtual void addDefaultAtoms() {
     return ExecutableWriter<ELFT>::addDefaultAtoms();
   }
 
 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(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter<ELFT>::createImplicitFiles(result);
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86TargetHandler.h

 
 namespace lld {
 namespace elf {
 
 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());
   }
 
   void registerRelocationNames(Registry &registry) override;
 
   const X86TargetRelocationHandler &getRelocationHandler() const override {
     return *(_x86RelocationHandler.get());
   }
 
   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;
 };
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp

 #include "X86RelocationHandler.h"
 
 using namespace lld;
 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:
     llvm_unreachable("unsupported output type");
   }
 }
 
 #define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
 
 const Registry::KindStrings X86TargetHandler::kindStrings[] = {
 #include "llvm/Support/ELFRelocs/i386.def"
   LLD_KIND_STRING_END
 };
 
 #undef ELF_RELOC
 
 void X86TargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::x86,
                         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()) {}

lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

 #include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
 
 namespace lld {
 namespace elf {
 
 class X86_64DynamicLibraryWriter : public DynamicLibraryWriter<X86_64ELFType> {
 public:
-  X86_64DynamicLibraryWriter(X86_64LinkingContext &context,
+  X86_64DynamicLibraryWriter(X86_64LinkingContext &ctx,
                              X86_64TargetLayout &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
   virtual bool createImplicitFiles(std::vector<std::unique_ptr<File>> &);
 
   virtual void finalizeDefaultAtomValues() {
     return DynamicLibraryWriter::finalizeDefaultAtomValues();
public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   std::unique_ptr<GOTFile> _gotFile;
 };
 
 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) {
   DynamicLibraryWriter::createImplicitFiles(result);
   _gotFile->addAtom(*new (_gotFile->_alloc) GLOBAL_OFFSET_TABLEAtom(*_gotFile));
   _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
   result.push_back(std::move(_gotFile));
   return true;
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

 #include "X86_64ElfType.h"
 #include "X86_64LinkingContext.h"
 
 namespace lld {
 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
   virtual bool
   createImplicitFiles(std::vector<std::unique_ptr<File>> &result) {
     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;
   }
 
   virtual void finalizeDefaultAtomValues() {
     return ExecutableWriter::finalizeDefaultAtomValues();
   }
 
   virtual void addDefaultAtoms() {
     return ExecutableWriter::addDefaultAtoms();
   }
 
 private:
   class GOTFile : public SimpleFile {
   public:
     GOTFile(const ELFLinkingContext &eti) : SimpleFile("GOTFile") {}
     llvm::BumpPtrAllocator _alloc;
   };
 
   std::unique_ptr<GOTFile> _gotFile;
-  X86_64LinkingContext &_context;
+  X86_64LinkingContext &_ctx;
 };
 
 } // namespace elf
 } // namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h

 #include "X86_64LinkingContext.h"
 #include "X86_64RelocationHandler.h"
 #include "lld/Core/Simple.h"
 
 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");
     sortOutputSectionByPriority(".fini_array", ".fini_array");
   }
 };
 
 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());
   }
 
   void registerRelocationNames(Registry &registry) override;
 
   const X86_64TargetRelocationHandler &getRelocationHandler() const override {
     return *(_x86_64RelocationHandler.get());
   }
 
   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;
 };
 
 } // end namespace elf
 } // end namespace lld
 
 #endif

lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp

 #include "X86_64DynamicLibraryWriter.h"
 #include "X86_64ExecutableWriter.h"
 #include "X86_64LinkingContext.h"
 #include "X86_64TargetHandler.h"
 
 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())) {}
 
 void X86_64TargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF,
                         Reference::KindArch::x86_64, kindStrings);
 }
 
 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:
     llvm_unreachable("unsupported output type");
   }
 }
 
 #define ELF_RELOC(name, value) LLD_KIND_STRING_ENTRY(name),
 
 const Registry::KindStrings X86_64TargetHandler::kindStrings[] = {
 #include "llvm/Support/ELFRelocs/x86_64.def"
   LLD_KIND_STRING_ENTRY(LLD_R_X86_64_GOTRELINDEX),
   LLD_KIND_STRING_END
 };
 
 #undef ELF_RELOC