Index: lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h
@@ -19,7 +19,7 @@
 template <class ELFT>
 class AArch64DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
-  AArch64DynamicLibraryWriter(AArch64LinkingContext &context,
+  AArch64DynamicLibraryWriter(AArch64LinkingContext &ctx,
                               AArch64TargetLayout<ELFT> &layout);
 
 protected:
@@ -42,16 +42,15 @@
   };
 
   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(
Index: lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
+++ lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.h
@@ -18,7 +18,7 @@
 template <class ELFT>
 class AArch64ExecutableWriter : public ExecutableWriter<ELFT> {
 public:
-  AArch64ExecutableWriter(AArch64LinkingContext &context,
+  AArch64ExecutableWriter(AArch64LinkingContext &ctx,
                           AArch64TargetLayout<ELFT> &layout);
 
 protected:
@@ -41,22 +41,22 @@
   };
 
   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;
Index: lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h
+++ lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.h
@@ -23,13 +23,12 @@
 
 template <class ELFT> class AArch64TargetLayout : public TargetLayout<ELFT> {
 public:
-  AArch64TargetLayout(AArch64LinkingContext &context)
-      : TargetLayout<ELFT>(context) {}
+  AArch64TargetLayout(AArch64LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
 };
 
 class AArch64TargetHandler final : public DefaultTargetHandler<AArch64ELFType> {
 public:
-  AArch64TargetHandler(AArch64LinkingContext &context);
+  AArch64TargetHandler(AArch64LinkingContext &ctx);
 
   AArch64TargetLayout<AArch64ELFType> &getTargetLayout() override {
     return *(_AArch64TargetLayout.get());
@@ -42,18 +41,18 @@
   }
 
   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;
 };
Index: lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
===================================================================
--- lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
+++ lib/ReaderWriter/ELF/AArch64/AArch64TargetHandler.cpp
@@ -16,9 +16,9 @@
 using namespace lld;
 using namespace elf;
 
-AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &context)
-    : _context(context),
-      _AArch64TargetLayout(new AArch64TargetLayout<AArch64ELFType>(context)),
+AArch64TargetHandler::AArch64TargetHandler(AArch64LinkingContext &ctx)
+    : _ctx(ctx),
+      _AArch64TargetLayout(new AArch64TargetLayout<AArch64ELFType>(ctx)),
       _AArch64RelocationHandler(new AArch64TargetRelocationHandler()) {}
 
 void AArch64TargetHandler::registerRelocationNames(Registry &registry) {
@@ -27,13 +27,13 @@
 }
 
 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:
Index: lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
+++ lib/ReaderWriter/ELF/ARM/ARMExecutableWriter.h
@@ -24,8 +24,7 @@
 template <class ELFT>
 class ARMExecutableWriter : public ExecutableWriter<ELFT> {
 public:
-  ARMExecutableWriter(ARMLinkingContext &context,
-                      ARMTargetLayout<ELFT> &layout);
+  ARMExecutableWriter(ARMLinkingContext &ctx, ARMTargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
@@ -47,15 +46,14 @@
   std::error_code setELFHeader() override;
 
 private:
-  ARMLinkingContext &_context;
+  ARMLinkingContext &_ctx;
   ARMTargetLayout<ELFT> &_armLayout;
 };
 
 template <class ELFT>
-ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &context,
+ARMExecutableWriter<ELFT>::ARMExecutableWriter(ARMLinkingContext &ctx,
                                                ARMTargetLayout<ELFT> &layout)
-    : ExecutableWriter<ELFT>(context, layout), _context(context),
-      _armLayout(layout) {}
+    : ExecutableWriter<ELFT>(ctx, layout), _ctx(ctx), _armLayout(layout) {}
 
 template <class ELFT>
 bool ARMExecutableWriter<ELFT>::createImplicitFiles(
@@ -85,7 +83,7 @@
 unique_bump_ptr<SymbolTable<ELFT>>
     ARMExecutableWriter<ELFT>::createSymbolTable() {
   return unique_bump_ptr<SymbolTable<ELFT>>(
-      new (this->_alloc) ARMSymbolTable<ELFT>(this->_context));
+      new (this->_alloc) ARMSymbolTable<ELFT>(this->_ctx));
 }
 
 template <class ELFT>
@@ -105,7 +103,7 @@
     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)
Index: lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
===================================================================
--- lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
+++ lib/ReaderWriter/ELF/ARM/ARMSymbolTable.h
@@ -19,15 +19,15 @@
 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>
Index: lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
+++ lib/ReaderWriter/ELF/ARM/ARMTargetHandler.h
@@ -27,8 +27,7 @@
 
 template <class ELFT> class ARMTargetLayout : public TargetLayout<ELFT> {
 public:
-  ARMTargetLayout(ARMLinkingContext &context)
-      : TargetLayout<ELFT>(context) {}
+  ARMTargetLayout(ARMLinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
 
   uint64_t getTPOffset() {
     if (_tpOff.hasValue())
@@ -53,7 +52,7 @@
 
 class ARMTargetHandler final : public DefaultTargetHandler<ARMELFType> {
 public:
-  ARMTargetHandler(ARMLinkingContext &context);
+  ARMTargetHandler(ARMLinkingContext &ctx);
 
   ARMTargetLayout<ARMELFType> &getTargetLayout() override {
     return *(_armTargetLayout.get());
@@ -66,18 +65,18 @@
   }
 
   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;
 };
Index: lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
===================================================================
--- lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
+++ lib/ReaderWriter/ELF/ARM/ARMTargetHandler.cpp
@@ -15,11 +15,10 @@
 using namespace lld;
 using namespace elf;
 
-ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &context)
-    : _context(context), _armTargetLayout(
-          new ARMTargetLayout<ARMELFType>(context)),
-      _armRelocationHandler(new ARMTargetRelocationHandler(
-          *_armTargetLayout.get())) {}
+ARMTargetHandler::ARMTargetHandler(ARMLinkingContext &ctx)
+    : _ctx(ctx), _armTargetLayout(new ARMTargetLayout<ARMELFType>(ctx)),
+      _armRelocationHandler(
+          new ARMTargetRelocationHandler(*_armTargetLayout.get())) {}
 
 void ARMTargetHandler::registerRelocationNames(Registry &registry) {
   registry.addKindTable(Reference::KindNamespace::ELF, Reference::KindArch::ARM,
@@ -27,10 +26,10 @@
 }
 
 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");
   }
Index: lib/ReaderWriter/ELF/Chunk.h
===================================================================
--- lib/ReaderWriter/ELF/Chunk.h
+++ lib/ReaderWriter/ELF/Chunk.h
@@ -45,9 +45,9 @@
   /// \brief the ContentType of the chunk
   enum ContentType : uint8_t{ Unknown, Header, Code, Data, Note, TLS };
 
-  Chunk(StringRef name, Kind kind, const ELFLinkingContext &context)
-      : _name(name), _kind(kind), _fsize(0), _msize(0), _alignment(0), _order(0),
-        _ordinal(1), _start(0), _fileoffset(0), _context(context) {}
+  Chunk(StringRef name, Kind kind, const ELFLinkingContext &ctx)
+      : _name(name), _kind(kind), _fsize(0), _msize(0), _alignment(0),
+        _order(0), _ordinal(1), _start(0), _fileoffset(0), _ctx(ctx) {}
   virtual ~Chunk() {}
   // The name of the chunk
   StringRef name() const { return _name; }
@@ -93,7 +93,7 @@
   uint64_t _ordinal;
   uint64_t _start;
   uint64_t _fileoffset;
-  const ELFLinkingContext &_context;
+  const ELFLinkingContext &_ctx;
 };
 
 } // end namespace elf
Index: lib/ReaderWriter/ELF/DefaultLayout.h
===================================================================
--- lib/ReaderWriter/ELF/DefaultLayout.h
+++ lib/ReaderWriter/ELF/DefaultLayout.h
@@ -170,8 +170,8 @@
 
   typedef llvm::DenseSet<const Atom *> AtomSetT;
 
-  DefaultLayout(ELFLinkingContext &context)
-      : _context(context), _linkerScriptSema(context.linkerScriptSema()) {}
+  DefaultLayout(ELFLinkingContext &ctx)
+      : _ctx(ctx), _linkerScriptSema(ctx.linkerScriptSema()) {}
 
   /// \brief Return the section order for a input section
   SectionOrder getSectionOrder(StringRef name, int32_t contentType,
@@ -283,7 +283,7 @@
   RelocationTable<ELFT> *getDynamicRelocationTable() {
     if (!_dynamicRelocationTable) {
       _dynamicRelocationTable = std::move(createRelocationTable(
-          _context.isRelaOutputFormat() ? ".rela.dyn" : ".rel.dyn",
+          _ctx.isRelaOutputFormat() ? ".rela.dyn" : ".rel.dyn",
           ORDER_DYNAMIC_RELOCS));
       addSection(_dynamicRelocationTable.get());
     }
@@ -294,7 +294,7 @@
   RelocationTable<ELFT> *getPLTRelocationTable() {
     if (!_pltRelocationTable) {
       _pltRelocationTable = std::move(createRelocationTable(
-          _context.isRelaOutputFormat() ? ".rela.plt" : ".rel.plt",
+          _ctx.isRelaOutputFormat() ? ".rela.plt" : ".rel.plt",
           ORDER_DYNAMIC_PLT_RELOCS));
       addSection(_pltRelocationTable.get());
     }
@@ -335,7 +335,7 @@
   virtual unique_bump_ptr<RelocationTable<ELFT>>
   createRelocationTable(StringRef name, int32_t order) {
     return unique_bump_ptr<RelocationTable<ELFT>>(
-        new (_allocator) RelocationTable<ELFT>(_context, name, order));
+        new (_allocator) RelocationTable<ELFT>(_ctx, name, order));
   }
 
 private:
@@ -358,7 +358,7 @@
   std::vector<lld::AtomLayout *> _absoluteAtoms;
   AtomSetT _referencedDynAtoms;
   llvm::StringSet<> _copiedDynSymNames;
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   script::Sema &_linkerScriptSema;
 };
 
@@ -570,7 +570,7 @@
 AtomSection<ELFT> *DefaultLayout<ELFT>::createSection(
     StringRef sectionName, int32_t contentType,
     DefinedAtom::ContentPermissions permissions, SectionOrder sectionOrder) {
-  return new (_allocator) AtomSection<ELFT>(_context, sectionName, contentType,
+  return new (_allocator) AtomSection<ELFT>(_ctx, sectionName, contentType,
                                             permissions, sectionOrder);
 }
 
@@ -617,10 +617,10 @@
     // Add runtime relocations to the .rela section.
     for (const auto &reloc : *definedAtom) {
       bool isLocalReloc = true;
-      if (_context.isDynamicRelocation(*reloc)) {
+      if (_ctx.isDynamicRelocation(*reloc)) {
         getDynamicRelocationTable()->addRelocation(*definedAtom, *reloc);
         isLocalReloc = false;
-      } else if (_context.isPLTRelocation(*reloc)) {
+      } else if (_ctx.isPLTRelocation(*reloc)) {
         getPLTRelocationTable()->addRelocation(*definedAtom, *reloc);
         isLocalReloc = false;
       }
@@ -632,7 +632,7 @@
       if (isa<UndefinedAtom>(reloc->target()) && isLocalReloc)
         continue;
 
-      if (_context.isCopyRelocation(*reloc)) {
+      if (_ctx.isCopyRelocation(*reloc)) {
         _copiedDynSymNames.insert(definedAtom->name());
         continue;
       }
@@ -716,7 +716,7 @@
 
 template <class ELFT> void DefaultLayout<ELFT>::assignSectionsToSegments() {
   ScopedTask task(getDefaultDomain(), "assignSectionsToSegments");
-  ELFLinkingContext::OutputMagic outputMagic = _context.getOutputMagic();
+  ELFLinkingContext::OutputMagic outputMagic = _ctx.getOutputMagic();
   // sort the sections by their order as defined by the layout
   sortInputSections();
 
@@ -752,7 +752,7 @@
 
         int64_t lookupSectionFlag = osi->flags();
         if ((!(lookupSectionFlag & llvm::ELF::SHF_WRITE)) &&
-            (_context.mergeRODataToTextSegment()))
+            (_ctx.mergeRODataToTextSegment()))
           lookupSectionFlag &= ~llvm::ELF::SHF_EXECINSTR;
 
         // Merge string sections into Data segment itself
@@ -774,8 +774,8 @@
           if (!additionalSegmentInsert.second) {
             segment = additionalSegmentInsert.first->second;
           } else {
-            segment = new (_allocator)
-                Segment<ELFT>(_context, segmentName, segmentType);
+            segment =
+                new (_allocator) Segment<ELFT>(_ctx, segmentName, segmentType);
             additionalSegmentInsert.first->second = segment;
             _segments.push_back(segment);
           }
@@ -802,7 +802,7 @@
           segment = segmentInsert.first->second;
         } else {
           segment = new (_allocator)
-              Segment<ELFT>(_context, "PT_LOAD", llvm::ELF::PT_LOAD);
+              Segment<ELFT>(_ctx, "PT_LOAD", llvm::ELF::PT_LOAD);
           segmentInsert.first->second = segment;
           _segments.push_back(segment);
         }
@@ -815,9 +815,8 @@
       }
     }
   }
-  if (_context.isDynamic() && !_context.isDynamicLibrary()) {
-    Segment<ELFT> *segment =
-        new (_allocator) ProgramHeaderSegment<ELFT>(_context);
+  if (_ctx.isDynamic() && !_ctx.isDynamicLibrary()) {
+    Segment<ELFT> *segment = new (_allocator) ProgramHeaderSegment<ELFT>(_ctx);
     _segments.push_back(segment);
     segment->append(_elfHeader);
     segment->append(_programHeader);
@@ -832,7 +831,7 @@
 
   std::sort(_segments.begin(), _segments.end(), Segment<ELFT>::compareSegments);
 
-  uint64_t baseAddress = _context.getBaseAddress();
+  uint64_t baseAddress = _ctx.getBaseAddress();
 
   // HACK: This is a super dirty hack. The elf header and program header are
   // not part of a section, but we need them to be loaded at the base address
@@ -1039,7 +1038,7 @@
       _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);
   }
 }
Index: lib/ReaderWriter/ELF/DynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/DynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/DynamicLibraryWriter.h
@@ -25,9 +25,9 @@
 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);
Index: lib/ReaderWriter/ELF/ELFFile.h
===================================================================
--- lib/ReaderWriter/ELF/ELFFile.h
+++ lib/ReaderWriter/ELF/ELFFile.h
@@ -445,8 +445,8 @@
 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) {
Index: lib/ReaderWriter/ELF/ExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/ExecutableWriter.h
+++ lib/ReaderWriter/ELF/ExecutableWriter.h
@@ -25,9 +25,9 @@
 template<class ELFT>
 class ExecutableWriter : public OutputELFWriter<ELFT> {
 public:
-  ExecutableWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout)
-      : OutputELFWriter<ELFT>(context, layout),
-        _runtimeFile(new RuntimeFile<ELFT>(context, "C runtime")) {}
+  ExecutableWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout)
+      : OutputELFWriter<ELFT>(ctx, layout),
+        _runtimeFile(new RuntimeFile<ELFT>(ctx, "C runtime")) {}
 
 protected:
   virtual void buildDynamicSymbolTable(const File &file);
@@ -56,8 +56,8 @@
         if (!da)
           continue;
         if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
-            !this->_context.isDynamicallyExportedSymbol(da->name()) &&
-            !(this->_context.shouldExportDynamic() &&
+            !this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
+            !(this->_ctx.shouldExportDynamic() &&
               da->scope() == Atom::Scope::scopeGlobal))
           continue;
         this->_dynamicSymbolTable->addSymbol(atom->_atom, section->ordinal(),
@@ -65,7 +65,7 @@
       }
 
   // Put weak symbols in the dynamic symbol table.
-  if (this->_context.isDynamic()) {
+  if (this->_ctx.isDynamic()) {
     for (const UndefinedAtom *a : file.undefined()) {
       if (this->_layout.isReferencedByDefinedAtom(a) &&
           a->canBeNull() != UndefinedAtom::canBeNullNever)
@@ -81,7 +81,7 @@
 template<class ELFT>
 void ExecutableWriter<ELFT>::addDefaultAtoms() {
   OutputELFWriter<ELFT>::addDefaultAtoms();
-  _runtimeFile->addUndefinedAtom(this->_context.entrySymbolName());
+  _runtimeFile->addUndefinedAtom(this->_ctx.entrySymbolName());
   _runtimeFile->addAbsoluteAtom("__bss_start");
   _runtimeFile->addAbsoluteAtom("__bss_end");
   _runtimeFile->addAbsoluteAtom("_end");
@@ -90,7 +90,7 @@
   _runtimeFile->addAbsoluteAtom("__preinit_array_end");
   _runtimeFile->addAbsoluteAtom("__init_array_start");
   _runtimeFile->addAbsoluteAtom("__init_array_end");
-  if (this->_context.isRelaOutputFormat()) {
+  if (this->_ctx.isRelaOutputFormat()) {
     _runtimeFile->addAbsoluteAtom("__rela_iplt_start");
     _runtimeFile->addAbsoluteAtom("__rela_iplt_end");
   } else {
@@ -114,10 +114,10 @@
 
 template <class ELFT> void ExecutableWriter<ELFT>::createDefaultSections() {
   OutputELFWriter<ELFT>::createDefaultSections();
-  if (this->_context.isDynamic()) {
+  if (this->_ctx.isDynamic()) {
     _interpSection.reset(new (this->_alloc) InterpSection<ELFT>(
-        this->_context, ".interp", DefaultLayout<ELFT>::ORDER_INTERP,
-        this->_context.getInterpreter()));
+        this->_ctx, ".interp", DefaultLayout<ELFT>::ORDER_INTERP,
+        this->_ctx.getInterpreter()));
     this->_layout.addSection(_interpSection.get());
   }
 }
@@ -148,7 +148,7 @@
 
   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");
Index: lib/ReaderWriter/ELF/HeaderChunks.h
===================================================================
--- lib/ReaderWriter/ELF/HeaderChunks.h
+++ lib/ReaderWriter/ELF/HeaderChunks.h
@@ -63,8 +63,8 @@
         (ELFT::TargetEndianness == llvm::support::little)
             ? llvm::ELF::ELFDATA2LSB
             : llvm::ELF::ELFDATA2MSB;
-    _eh.e_type = this->_context.getOutputELFType();
-    _eh.e_machine = this->_context.getOutputMachine();
+    _eh.e_type = this->_ctx.getOutputELFType();
+    _eh.e_machine = this->_ctx.getOutputMachine();
   }
 
 private:
@@ -72,8 +72,8 @@
 };
 
 template <class ELFT>
-ELFHeader<ELFT>::ELFHeader(const ELFLinkingContext &context)
-    : Chunk<ELFT>("elfhdr", Chunk<ELFT>::Kind::ELFHeader, context) {
+ELFHeader<ELFT>::ELFHeader(const ELFLinkingContext &ctx)
+    : Chunk<ELFT>("elfhdr", Chunk<ELFT>::Kind::ELFHeader, ctx) {
   this->_alignment = ELFT::Is64Bits ? 8 : 4;
   this->_fsize = sizeof(Elf_Ehdr);
   this->_msize = sizeof(Elf_Ehdr);
@@ -124,8 +124,8 @@
     uint64_t _flagsClear;
   };
 
-  ProgramHeader(const ELFLinkingContext &context)
-      : Chunk<ELFT>("elfphdr", Chunk<ELFT>::Kind::ProgramHeader, context) {
+  ProgramHeader(const ELFLinkingContext &ctx)
+      : Chunk<ELFT>("elfphdr", Chunk<ELFT>::Kind::ProgramHeader, ctx) {
     this->_alignment = ELFT::Is64Bits ? 8 : 4;
     resetProgramHeaders();
   }
@@ -197,7 +197,7 @@
 template <class ELFT>
 bool ProgramHeader<ELFT>::addSegment(Segment<ELFT> *segment) {
   bool allocatedNew = false;
-  ELFLinkingContext::OutputMagic outputMagic = this->_context.getOutputMagic();
+  ELFLinkingContext::OutputMagic outputMagic = this->_ctx.getOutputMagic();
   // For segments that are not a loadable segment, we
   // just pick the values directly from the segment as there
   // wouldnt be any slices within that
@@ -300,9 +300,8 @@
 };
 
 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);
Index: lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonDynamicLibraryWriter.h
@@ -22,7 +22,7 @@
 class HexagonDynamicLibraryWriter : public DynamicLibraryWriter<ELFT>,
                                     public HexagonELFWriter<ELFT> {
 public:
-  HexagonDynamicLibraryWriter(HexagonLinkingContext &context,
+  HexagonDynamicLibraryWriter(HexagonLinkingContext &ctx,
                               HexagonTargetLayout<ELFT> &layout);
 
 protected:
@@ -43,18 +43,18 @@
     _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(
Index: lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonELFWriters.h
@@ -20,9 +20,9 @@
 
 template <typename ELFT> class HexagonELFWriter {
 public:
-  HexagonELFWriter(HexagonLinkingContext &context,
+  HexagonELFWriter(HexagonLinkingContext &ctx,
                    HexagonTargetLayout<ELFT> &targetLayout)
-      : _hexagonLinkingContext(context), _hexagonTargetLayout(targetLayout) {}
+      : _ctx(ctx), _hexagonTargetLayout(targetLayout) {}
 
 protected:
   bool setELFHeader(ELFHeader<ELFT> &elfHeader) {
@@ -34,7 +34,7 @@
   }
 
   void finalizeHexagonRuntimeAtomValues() {
-    if (_hexagonLinkingContext.isDynamic()) {
+    if (_ctx.isDynamic()) {
       auto gotAtomIter =
           _hexagonTargetLayout.findAbsoluteAtom("_GLOBAL_OFFSET_TABLE_");
       auto gotpltSection = _hexagonTargetLayout.findOutputSection(".got.plt");
@@ -52,7 +52,7 @@
   }
 
 private:
-  HexagonLinkingContext &_hexagonLinkingContext;
+  HexagonLinkingContext &_ctx;
   HexagonTargetLayout<ELFT> &_hexagonTargetLayout;
 };
 
Index: lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonExecutableAtoms.h
@@ -20,8 +20,8 @@
 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
Index: lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonExecutableWriter.h
@@ -23,7 +23,7 @@
 class HexagonExecutableWriter : public ExecutableWriter<ELFT>,
                                 public HexagonELFWriter<ELFT> {
 public:
-  HexagonExecutableWriter(HexagonLinkingContext &context,
+  HexagonExecutableWriter(HexagonLinkingContext &ctx,
                           HexagonTargetLayout<ELFT> &layout);
 
 protected:
@@ -41,24 +41,23 @@
 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(
Index: lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonSectionChunks.h
@@ -20,9 +20,9 @@
 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;
Index: lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
+++ lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.h
@@ -118,13 +118,11 @@
   }
 
   std::unique_ptr<Reader> getObjReader() override {
-    return std::unique_ptr<Reader>(
-        new HexagonELFObjectReader(_hexagonLinkingContext));
+    return std::unique_ptr<Reader>(new HexagonELFObjectReader(_ctx));
   }
 
   std::unique_ptr<Reader> getDSOReader() override {
-    return std::unique_ptr<Reader>(
-        new HexagonELFDSOReader(_hexagonLinkingContext));
+    return std::unique_ptr<Reader>(new HexagonELFDSOReader(_ctx));
   }
 
   std::unique_ptr<Writer> getWriter() override;
@@ -132,7 +130,7 @@
 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;
Index: lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
===================================================================
--- lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
+++ lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp
@@ -18,21 +18,21 @@
 
 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:
Index: lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/Mips/MipsDynamicLibraryWriter.h
@@ -74,16 +74,16 @@
 template <class ELFT>
 unique_bump_ptr<SymbolTable<ELFT>>
     MipsDynamicLibraryWriter<ELFT>::createSymbolTable() {
-  return unique_bump_ptr<SymbolTable<ELFT>>(new (
-      this->_alloc) MipsSymbolTable<ELFT>(this->_context));
+  return unique_bump_ptr<SymbolTable<ELFT>>(
+      new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
 }
 
 /// \brief create dynamic table
 template <class ELFT>
 unique_bump_ptr<DynamicTable<ELFT>>
     MipsDynamicLibraryWriter<ELFT>::createDynamicTable() {
-  return unique_bump_ptr<DynamicTable<ELFT>>(new (
-      this->_alloc) MipsDynamicTable<ELFT>(this->_context, _mipsTargetLayout));
+  return unique_bump_ptr<DynamicTable<ELFT>>(
+      new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _mipsTargetLayout));
 }
 
 /// \brief create dynamic symbol table
@@ -91,8 +91,8 @@
 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
Index: lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h
+++ lib/ReaderWriter/ELF/Mips/MipsExecutableWriter.h
@@ -56,7 +56,7 @@
   if (ec)
     return ec;
 
-  StringRef entryName = this->_context.entrySymbolName();
+  StringRef entryName = this->_ctx.entrySymbolName();
   if (const AtomLayout *al = this->_layout.findAtomLayoutByName(entryName)) {
     const auto *ea = cast<DefinedAtom>(al->_atom);
     if (ea->codeModel() == DefinedAtom::codeMipsMicro ||
@@ -87,8 +87,8 @@
           continue;
 
         if (da->dynamicExport() != DefinedAtom::dynamicExportAlways &&
-            !this->_context.isDynamicallyExportedSymbol(da->name()) &&
-            !(this->_context.shouldExportDynamic() &&
+            !this->_ctx.isDynamicallyExportedSymbol(da->name()) &&
+            !(this->_ctx.shouldExportDynamic() &&
               da->scope() == Atom::Scope::scopeGlobal))
           continue;
 
@@ -127,16 +127,16 @@
 template <class ELFT>
 unique_bump_ptr<SymbolTable<ELFT>>
     MipsExecutableWriter<ELFT>::createSymbolTable() {
-  return unique_bump_ptr<SymbolTable<ELFT>>(new (
-      this->_alloc) MipsSymbolTable<ELFT>(this->_context));
+  return unique_bump_ptr<SymbolTable<ELFT>>(
+      new (this->_alloc) MipsSymbolTable<ELFT>(this->_ctx));
 }
 
 /// \brief create dynamic table
 template <class ELFT>
 unique_bump_ptr<DynamicTable<ELFT>>
     MipsExecutableWriter<ELFT>::createDynamicTable() {
-  return unique_bump_ptr<DynamicTable<ELFT>>(new (
-      this->_alloc) MipsDynamicTable<ELFT>(this->_context, _mipsTargetLayout));
+  return unique_bump_ptr<DynamicTable<ELFT>>(
+      new (this->_alloc) MipsDynamicTable<ELFT>(this->_ctx, _mipsTargetLayout));
 }
 
 /// \brief create dynamic symbol table
@@ -144,8 +144,8 @@
 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
Index: lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h
===================================================================
--- lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h
+++ lib/ReaderWriter/ELF/Mips/MipsSectionChunks.h
@@ -139,9 +139,9 @@
       ELFT::Is64Bits && ELFT::TargetEndianness == llvm::support::little;
 
 public:
-  MipsRelocationTable(const ELFLinkingContext &context, StringRef str,
+  MipsRelocationTable(const ELFLinkingContext &ctx, StringRef str,
                       int32_t order)
-      : RelocationTable<ELFT>(context, str, order) {}
+      : RelocationTable<ELFT>(ctx, str, order) {}
 
 protected:
   void writeRela(ELFWriter *writer, Elf_Rela &r, const DefinedAtom &atom,
@@ -150,7 +150,7 @@
     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;
Index: lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h
+++ lib/ReaderWriter/ELF/Mips/MipsTargetHandler.h
@@ -77,9 +77,8 @@
 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:
Index: lib/ReaderWriter/ELF/OutputELFWriter.h
===================================================================
--- lib/ReaderWriter/ELF/OutputELFWriter.h
+++ lib/ReaderWriter/ELF/OutputELFWriter.h
@@ -35,9 +35,9 @@
 template<class ELFT>
 class SymbolFile : public RuntimeFile<ELFT> {
 public:
-  SymbolFile(ELFLinkingContext &context)
-      : RuntimeFile<ELFT>(context, "Dynamic absolute symbols"),
-        _atomsAdded(false) {}
+  SymbolFile(ELFLinkingContext &ctx)
+      : RuntimeFile<ELFT>(ctx, "Dynamic absolute symbols"), _atomsAdded(false) {
+  }
 
   Atom *addAbsoluteAtom(StringRef symbolName) override {
     auto *a = RuntimeFile<ELFT>::addAbsoluteAtom(symbolName);
@@ -59,13 +59,13 @@
 class DynamicSymbolFile : public SimpleArchiveLibraryFile {
   typedef std::function<void(StringRef, RuntimeFile<ELFT> &)> Resolver;
 public:
-  DynamicSymbolFile(ELFLinkingContext &context, Resolver resolver)
+  DynamicSymbolFile(ELFLinkingContext &ctx, Resolver resolver)
       : SimpleArchiveLibraryFile("Dynamically added runtime symbols"),
-        _context(context), _resolver(resolver) {}
+        _ctx(ctx), _resolver(resolver) {}
 
   File *find(StringRef sym, bool dataSymbolOnly) override {
     if (!_file)
-      _file.reset(new (_alloc) SymbolFile<ELFT>(_context));
+      _file.reset(new (_alloc) SymbolFile<ELFT>(_ctx));
 
     assert(!_file->hasAtoms() && "The file shouldn't have atoms yet");
     _resolver(sym, *_file);
@@ -74,7 +74,7 @@
   }
 
 private:
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   Resolver _resolver;
 
   // The allocator should go before bump pointers because of
@@ -99,7 +99,7 @@
   typedef Elf_Sym_Impl<ELFT> Elf_Sym;
   typedef Elf_Dyn_Impl<ELFT> Elf_Dyn;
 
-  OutputELFWriter(ELFLinkingContext &context, TargetLayout<ELFT> &layout);
+  OutputELFWriter(ELFLinkingContext &ctx, TargetLayout<ELFT> &layout);
 
 protected:
   // build the sections that need to be created
@@ -184,7 +184,7 @@
 
   llvm::BumpPtrAllocator _alloc;
 
-  ELFLinkingContext &_context;
+  ELFLinkingContext &_ctx;
   TargetHandler<ELFT> &_targetHandler;
 
   typedef llvm::DenseMap<const Atom *, uint64_t> AtomToAddress;
@@ -215,11 +215,10 @@
 //  OutputELFWriter
 //===----------------------------------------------------------------------===//
 template <class ELFT>
-OutputELFWriter<ELFT>::OutputELFWriter(ELFLinkingContext &context,
+OutputELFWriter<ELFT>::OutputELFWriter(ELFLinkingContext &ctx,
                                        TargetLayout<ELFT> &layout)
-    : _context(context), _targetHandler(context.getTargetHandler<ELFT>()),
-      _layout(layout),
-      _scriptFile(new RuntimeFile<ELFT>(context, "Linker script runtime")) {}
+    : _ctx(ctx), _targetHandler(ctx.getTargetHandler<ELFT>()), _layout(layout),
+      _scriptFile(new RuntimeFile<ELFT>(ctx, "Linker script runtime")) {}
 
 template <class ELFT>
 void OutputELFWriter<ELFT>::buildChunks(const File &file) {
@@ -274,20 +273,20 @@
     if (isNeededTagRequired(sla))
       _soNeeded.insert(sla->loadName());
   }
-  for (const std::unique_ptr<Node> &node : _context.getNodes()) {
+  for (const std::unique_ptr<Node> &node : _ctx.getNodes()) {
     StringRef soname = maybeGetSOName(node.get());
     if (!soname.empty())
       _soNeeded.insert(soname);
   }
   // Never mark the dynamic linker as DT_NEEDED
-  _soNeeded.erase(sys::path::filename(_context.getInterpreter()));
+  _soNeeded.erase(sys::path::filename(_ctx.getInterpreter()));
   for (const auto &loadName : _soNeeded) {
     Elf_Dyn dyn;
     dyn.d_tag = DT_NEEDED;
     dyn.d_un.d_val = _dynamicStringTable->addString(loadName.getKey());
     _dynamicTable->addEntry(dyn);
   }
-  const auto &rpathList = _context.getRpathList();
+  const auto &rpathList = _ctx.getRpathList();
   if (!rpathList.empty()) {
     auto rpath = new (_alloc) std::string(join(rpathList.begin(),
       rpathList.end(), ":"));
@@ -296,8 +295,8 @@
     dyn.d_un.d_val = _dynamicStringTable->addString(*rpath);
     _dynamicTable->addEntry(dyn);
   }
-  StringRef soname = _context.sharedObjectName();
-  if (!soname.empty() && _context.getOutputELFType() == llvm::ELF::ET_DYN) {
+  StringRef soname = _ctx.sharedObjectName();
+  if (!soname.empty() && _ctx.getOutputELFType() == llvm::ELF::ET_DYN) {
     Elf_Dyn dyn;
     dyn.d_tag = DT_SONAME;
     dyn.d_un.d_val = _dynamicStringTable->addString(soname);
@@ -367,7 +366,7 @@
 
 template <class ELFT> void OutputELFWriter<ELFT>::addDefaultAtoms() {
   const llvm::StringSet<> &symbols =
-      _context.linkerScriptSema().getScriptDefinedSymbols();
+      _ctx.linkerScriptSema().getScriptDefinedSymbols();
   for (auto &sym : symbols)
     _scriptFile->addAbsoluteAtom(sym.getKey());
 }
@@ -380,7 +379,7 @@
   auto callback = [this](StringRef sym, RuntimeFile<ELFT> &file) {
     processUndefinedSymbol(sym, file);
   };
-  auto &ctx = const_cast<ELFLinkingContext &>(_context);
+  auto &ctx = const_cast<ELFLinkingContext &>(_ctx);
   ctx.setUndefinesResolver(
       llvm::make_unique<DynamicSymbolFile<ELFT>>(ctx, std::move(callback)));
   // Add script defined symbols
@@ -391,28 +390,28 @@
 template <class ELFT>
 void OutputELFWriter<ELFT>::finalizeDefaultAtomValues() {
   const llvm::StringSet<> &symbols =
-      _context.linkerScriptSema().getScriptDefinedSymbols();
+      _ctx.linkerScriptSema().getScriptDefinedSymbols();
   for (auto &sym : symbols) {
     uint64_t res =
-        _context.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
+        _ctx.linkerScriptSema().getLinkerScriptExprValue(sym.getKey());
     auto a = _layout.findAbsoluteAtom(sym.getKey());
     (*a)->_virtualAddr = res;
   }
 }
 
 template <class ELFT> void OutputELFWriter<ELFT>::createDefaultSections() {
-  _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_context));
-  _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_context));
+  _elfHeader.reset(new (_alloc) ELFHeader<ELFT>(_ctx));
+  _programHeader.reset(new (_alloc) ProgramHeader<ELFT>(_ctx));
   _layout.setHeader(_elfHeader.get());
   _layout.setProgramHeader(_programHeader.get());
 
   _symtab = std::move(this->createSymbolTable());
   _strtab.reset(new (_alloc) StringTable<ELFT>(
-      _context, ".strtab", DefaultLayout<ELFT>::ORDER_STRING_TABLE));
+      _ctx, ".strtab", DefaultLayout<ELFT>::ORDER_STRING_TABLE));
   _shstrtab.reset(new (_alloc) StringTable<ELFT>(
-      _context, ".shstrtab", DefaultLayout<ELFT>::ORDER_SECTION_STRINGS));
+      _ctx, ".shstrtab", DefaultLayout<ELFT>::ORDER_SECTION_STRINGS));
   _shdrtab.reset(new (_alloc) SectionHeader<ELFT>(
-      _context, DefaultLayout<ELFT>::ORDER_SECTION_HEADERS));
+      _ctx, DefaultLayout<ELFT>::ORDER_SECTION_HEADERS));
   _layout.addSection(_symtab.get());
   _layout.addSection(_strtab.get());
   _layout.addSection(_shstrtab.get());
@@ -426,19 +425,19 @@
     if (!section || section->outputSectionName() != ".eh_frame")
       continue;
     _ehFrameHeader.reset(new (_alloc) EHFrameHeader<ELFT>(
-        _context, ".eh_frame_hdr", _layout,
+        _ctx, ".eh_frame_hdr", _layout,
         DefaultLayout<ELFT>::ORDER_EH_FRAMEHDR));
     _layout.addSection(_ehFrameHeader.get());
     break;
   }
 
-  if (_context.isDynamic()) {
+  if (_ctx.isDynamic()) {
     _dynamicTable = std::move(createDynamicTable());
     _dynamicStringTable.reset(new (_alloc) StringTable<ELFT>(
-        _context, ".dynstr", DefaultLayout<ELFT>::ORDER_DYNAMIC_STRINGS, true));
+        _ctx, ".dynstr", DefaultLayout<ELFT>::ORDER_DYNAMIC_STRINGS, true));
     _dynamicSymbolTable = std::move(createDynamicSymbolTable());
     _hashTable.reset(new (_alloc) HashSection<ELFT>(
-        _context, ".hash", DefaultLayout<ELFT>::ORDER_HASH));
+        _ctx, ".hash", DefaultLayout<ELFT>::ORDER_HASH));
     // Set the hash table in the dynamic symbol table so that the entries in the
     // hash table can be created
     _dynamicSymbolTable->setHashTable(_hashTable.get());
@@ -463,16 +462,15 @@
 unique_bump_ptr<SymbolTable<ELFT>>
     OutputELFWriter<ELFT>::createSymbolTable() {
   return unique_bump_ptr<SymbolTable<ELFT>>(new (_alloc) SymbolTable<ELFT>(
-      this->_context, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
+      this->_ctx, ".symtab", DefaultLayout<ELFT>::ORDER_SYMBOL_TABLE));
 }
 
 /// \brief create dynamic table
 template <class ELFT>
 unique_bump_ptr<DynamicTable<ELFT>>
     OutputELFWriter<ELFT>::createDynamicTable() {
-  return unique_bump_ptr<DynamicTable<ELFT>>(
-    new (_alloc) DynamicTable<ELFT>(
-      this->_context, _layout, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
+  return unique_bump_ptr<DynamicTable<ELFT>>(new (_alloc) DynamicTable<ELFT>(
+      this->_ctx, _layout, ".dynamic", DefaultLayout<ELFT>::ORDER_DYNAMIC));
 }
 
 /// \brief create dynamic symbol table
@@ -480,9 +478,9 @@
 unique_bump_ptr<DynamicSymbolTable<ELFT>>
     OutputELFWriter<ELFT>::createDynamicSymbolTable() {
   return unique_bump_ptr<DynamicSymbolTable<ELFT>>(
-    new (_alloc) DynamicSymbolTable<ELFT>(
-      this->_context, _layout, ".dynsym",
-      DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
+      new (_alloc)
+          DynamicSymbolTable<ELFT>(this->_ctx, _layout, ".dynsym",
+                                   DefaultLayout<ELFT>::ORDER_DYNAMIC_SYMBOLS));
 }
 
 template <class ELFT>
@@ -498,7 +496,7 @@
   _layout.assignSectionsToSegments();
 
   // Create the dynamic table entries
-  if (_context.isDynamic()) {
+  if (_ctx.isDynamic()) {
     _dynamicTable->createDefaultEntries();
     buildDynamicSymbolTable(file);
   }
@@ -517,7 +515,7 @@
 
   // Create symbol table and section string table
   // Do it only if -s is not specified.
-  if (!_context.stripSymbols())
+  if (!_ctx.stripSymbols())
     buildStaticSymbolTable(file);
 
   // Finalize the layout by calling the finalize() functions
@@ -530,15 +528,15 @@
   // for sections with no segments
   assignSectionsWithNoSegments();
 
-  if (_context.isDynamic())
+  if (_ctx.isDynamic())
     _dynamicTable->updateDynamicTable();
 
   return std::error_code();
 }
 
 template <class ELFT> std::error_code OutputELFWriter<ELFT>::setELFHeader() {
-  _elfHeader->e_type(_context.getOutputELFType());
-  _elfHeader->e_machine(_context.getOutputMachine());
+  _elfHeader->e_type(_ctx.getOutputELFType());
+  _elfHeader->e_machine(_ctx.getOutputMachine());
   _elfHeader->e_ident(ELF::EI_VERSION, 1);
   _elfHeader->e_ident(ELF::EI_OSABI, 0);
   _elfHeader->e_version(1);
@@ -549,7 +547,7 @@
   _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);
Index: lib/ReaderWriter/ELF/SectionChunks.h
===================================================================
--- lib/ReaderWriter/ELF/SectionChunks.h
+++ lib/ReaderWriter/ELF/SectionChunks.h
@@ -39,10 +39,10 @@
 /// \brief An ELF section.
 template <class ELFT> class Section : public Chunk<ELFT> {
 public:
-  Section(const ELFLinkingContext &context, StringRef sectionName,
+  Section(const ELFLinkingContext &ctx, StringRef sectionName,
           StringRef chunkName,
           typename Chunk<ELFT>::Kind k = Chunk<ELFT>::Kind::ELFSection)
-      : Chunk<ELFT>(chunkName, k, context), _outputSection(nullptr), _flags(0),
+      : Chunk<ELFT>(chunkName, k, ctx), _outputSection(nullptr), _flags(0),
         _entSize(0), _type(0), _link(0), _info(0),
         _isFirstSectionInOutputSection(false), _segmentType(SHT_NULL),
         _inputSectionName(sectionName), _outputSectionName(sectionName) {}
@@ -159,9 +159,9 @@
 /// \brief A section containing atoms.
 template <class ELFT> class AtomSection : public Section<ELFT> {
 public:
-  AtomSection(const ELFLinkingContext &context, StringRef sectionName,
+  AtomSection(const ELFLinkingContext &ctx, StringRef sectionName,
               int32_t contentType, int32_t permissions, int32_t order)
-      : Section<ELFT>(context, sectionName, "AtomSection",
+      : Section<ELFT>(ctx, sectionName, "AtomSection",
                       Chunk<ELFT>::Kind::AtomSection),
         _contentType(contentType), _contentPermissions(permissions),
         _isLoadedInMemory(true) {
@@ -283,10 +283,8 @@
   void printError(const std::string &errorStr, const AtomLayout &atom,
                   const Reference &ref) const {
     StringRef kindValStr;
-    if (!this->_context.registry().referenceKindToString(ref.kindNamespace(),
-                                                         ref.kindArch(),
-                                                         ref.kindValue(),
-                                                         kindValStr)) {
+    if (!this->_ctx.registry().referenceKindToString(
+            ref.kindNamespace(), ref.kindArch(), ref.kindValue(), kindValStr)) {
       kindValStr = "unknown";
     }
 
@@ -429,7 +427,7 @@
     uint8_t *atomContent = chunkBuffer + ai->_fileOffset;
     std::memcpy(atomContent, content.data(), contentSize);
     const TargetRelocationHandler &relHandler =
-        this->_context.template getTargetHandler<ELFT>().getRelocationHandler();
+        this->_ctx.template getTargetHandler<ELFT>().getRelocationHandler();
     for (const auto ref : *definedAtom) {
       if (std::error_code ec = relHandler.applyRelocation(*writer, buffer,
                                                           *ai, *ref)) {
@@ -599,9 +597,9 @@
 };
 
 template <class ELFT>
-StringTable<ELFT>::StringTable(const ELFLinkingContext &context,
-                               const char *str, int32_t order, bool dynamic)
-    : Section<ELFT>(context, str, "StringTable") {
+StringTable<ELFT>::StringTable(const ELFLinkingContext &ctx, const char *str,
+                               int32_t order, bool dynamic)
+    : Section<ELFT>(ctx, str, "StringTable") {
   // the string table has a NULL entry for which
   // add an empty string
   _strings.push_back("");
@@ -653,7 +651,7 @@
 public:
   typedef llvm::object::Elf_Sym_Impl<ELFT> Elf_Sym;
 
-  SymbolTable(const ELFLinkingContext &context, const char *str, int32_t order);
+  SymbolTable(const ELFLinkingContext &ctx, const char *str, int32_t order);
 
   /// \brief set the number of entries that would exist in the symbol
   /// table for the current link
@@ -723,9 +721,9 @@
 
 /// ELF Symbol Table
 template <class ELFT>
-SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &context,
-                               const char *str, int32_t order)
-    : Section<ELFT>(context, str, "SymbolTable") {
+SymbolTable<ELFT>::SymbolTable(const ELFLinkingContext &ctx, const char *str,
+                               int32_t order)
+    : Section<ELFT>(ctx, str, "SymbolTable") {
   this->setOrder(order);
   Elf_Sym symbol;
   std::memset(&symbol, 0, sizeof(Elf_Sym));
@@ -907,9 +905,9 @@
 
 template <class ELFT> class DynamicSymbolTable : public SymbolTable<ELFT> {
 public:
-  DynamicSymbolTable(const ELFLinkingContext &context,
-                     TargetLayout<ELFT> &layout, const char *str, int32_t order)
-      : SymbolTable<ELFT>(context, str, order), _hashTable(nullptr),
+  DynamicSymbolTable(const ELFLinkingContext &ctx, TargetLayout<ELFT> &layout,
+                     const char *str, int32_t order)
+      : SymbolTable<ELFT>(ctx, str, order), _hashTable(nullptr),
         _layout(layout) {
     this->_type = SHT_DYNSYM;
     this->_flags = SHF_ALLOC;
@@ -956,14 +954,13 @@
   typedef llvm::object::Elf_Rel_Impl<ELFT, false> Elf_Rel;
   typedef llvm::object::Elf_Rel_Impl<ELFT, true> Elf_Rela;
 
-  RelocationTable(const ELFLinkingContext &context, StringRef str,
-                  int32_t order)
-      : Section<ELFT>(context, str, "RelocationTable"), _symbolTable(nullptr) {
+  RelocationTable(const ELFLinkingContext &ctx, StringRef str, int32_t order)
+      : Section<ELFT>(ctx, str, "RelocationTable"), _symbolTable(nullptr) {
     this->setOrder(order);
     this->_flags = SHF_ALLOC;
     // Set the alignment properly depending on the target architecture
     this->_alignment = ELFT::Is64Bits ? 8 : 4;
-    if (context.isRelaOutputFormat()) {
+    if (ctx.isRelaOutputFormat()) {
       this->_entSize = sizeof(Elf_Rela);
       this->_type = SHT_RELA;
     } else {
@@ -1019,7 +1016,7 @@
     uint8_t *chunkBuffer = buffer.getBufferStart();
     uint8_t *dest = chunkBuffer + this->fileOffset();
     for (const auto &rel : _relocs) {
-      if (this->_context.isRelaOutputFormat()) {
+      if (this->_ctx.isRelaOutputFormat()) {
         auto &r = *reinterpret_cast<Elf_Rela *>(dest);
         writeRela(writer, r, *rel.first, *rel.second);
         DEBUG_WITH_TYPE("ELFRelocationTable",
@@ -1049,7 +1046,7 @@
     r.setSymbolAndType(getSymbolIndex(ref.target()), ref.kindValue(), false);
     r.r_offset = writer->addressOfAtom(&atom) + ref.offsetInAtom();
     // The addend is used only by relative relocations
-    if (this->_context.isRelativeReloc(ref))
+    if (this->_ctx.isRelativeReloc(ref))
       r.r_addend = writer->addressOfAtom(ref.target()) + ref.addend();
     else
       r.r_addend = 0;
@@ -1077,9 +1074,9 @@
   typedef llvm::object::Elf_Dyn_Impl<ELFT> Elf_Dyn;
   typedef std::vector<Elf_Dyn> EntriesT;
 
-  DynamicTable(const ELFLinkingContext &context, TargetLayout<ELFT> &layout,
+  DynamicTable(const ELFLinkingContext &ctx, TargetLayout<ELFT> &layout,
                StringRef str, int32_t order)
-      : Section<ELFT>(context, str, "DynamicSection"), _layout(layout) {
+      : Section<ELFT>(ctx, str, "DynamicSection"), _layout(layout) {
     this->setOrder(order);
     this->_entSize = sizeof(Elf_Dyn);
     this->_alignment = ELFT::Is64Bits ? 8 : 4;
@@ -1113,7 +1110,7 @@
   }
 
   virtual void createDefaultEntries() {
-    bool isRela = this->_context.isRelaOutputFormat();
+    bool isRela = this->_ctx.isRelaOutputFormat();
 
     Elf_Dyn dyn;
     dyn.d_un.d_val = 0;
@@ -1280,14 +1277,14 @@
   HashSection<ELFT> *_hashTable;
 
   const AtomLayout *getInitAtomLayout() {
-    auto al = _layout.findAtomLayoutByName(this->_context.initFunction());
+    auto al = _layout.findAtomLayoutByName(this->_ctx.initFunction());
     if (al && isa<DefinedAtom>(al->_atom))
       return al;
     return nullptr;
   }
 
   const AtomLayout *getFiniAtomLayout() {
-    auto al = _layout.findAtomLayoutByName(this->_context.finiFunction());
+    auto al = _layout.findAtomLayoutByName(this->_ctx.finiFunction());
     if (al && isa<DefinedAtom>(al->_atom))
       return al;
     return nullptr;
@@ -1296,9 +1293,9 @@
 
 template <class ELFT> class InterpSection : public Section<ELFT> {
 public:
-  InterpSection(const ELFLinkingContext &context, StringRef str, int32_t order,
+  InterpSection(const ELFLinkingContext &ctx, StringRef str, int32_t order,
                 StringRef interp)
-      : Section<ELFT>(context, str, "Dynamic:Interp"), _interp(interp) {
+      : Section<ELFT>(ctx, str, "Dynamic:Interp"), _interp(interp) {
     this->setOrder(order);
     this->_alignment = 1;
     // + 1 for null term.
@@ -1346,8 +1343,8 @@
   };
 
 public:
-  HashSection(const ELFLinkingContext &context, StringRef name, int32_t order)
-      : Section<ELFT>(context, name, "Dynamic:Hash"), _symbolTable(nullptr) {
+  HashSection(const ELFLinkingContext &ctx, StringRef name, int32_t order)
+      : Section<ELFT>(ctx, name, "Dynamic:Hash"), _symbolTable(nullptr) {
     this->setOrder(order);
     this->_entSize = 4;
     this->_type = SHT_HASH;
@@ -1449,9 +1446,9 @@
 
 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;
Index: lib/ReaderWriter/ELF/SegmentChunks.h
===================================================================
--- lib/ReaderWriter/ELF/SegmentChunks.h
+++ lib/ReaderWriter/ELF/SegmentChunks.h
@@ -100,7 +100,7 @@
   typedef typename std::vector<SegmentSlice<ELFT> *>::iterator SliceIter;
   typedef typename std::vector<Chunk<ELFT> *>::iterator SectionIter;
 
-  Segment(const ELFLinkingContext &context, StringRef name,
+  Segment(const ELFLinkingContext &ctx, StringRef name,
           const Layout::SegmentType type);
 
   /// \brief the Order of segments that appear in the output file
@@ -209,7 +209,7 @@
     }
   }
 
-  int pageSize() const { return this->_context.getPageSize(); }
+  int pageSize() const { return this->_ctx.getPageSize(); }
 
   int rawflags() const { return _atomflags; }
 
@@ -304,8 +304,8 @@
 /// The segment doesn't contain any slice
 template <class ELFT> class ProgramHeaderSegment : public Segment<ELFT> {
 public:
-  ProgramHeaderSegment(const ELFLinkingContext &context)
-      : Segment<ELFT>(context, "PHDR", llvm::ELF::PT_PHDR) {
+  ProgramHeaderSegment(const ELFLinkingContext &ctx)
+      : Segment<ELFT>(ctx, "PHDR", llvm::ELF::PT_PHDR) {
     this->_alignment = 8;
     this->_flags = (llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR);
   }
@@ -326,13 +326,13 @@
 };
 
 template <class ELFT>
-Segment<ELFT>::Segment(const ELFLinkingContext &context, StringRef name,
+Segment<ELFT>::Segment(const ELFLinkingContext &ctx, StringRef name,
                        const Layout::SegmentType type)
-    : Chunk<ELFT>(name, Chunk<ELFT>::Kind::ELFSegment, context),
-      _segmentType(type), _flags(0), _atomflags(0) {
+    : Chunk<ELFT>(name, Chunk<ELFT>::Kind::ELFSegment, ctx), _segmentType(type),
+      _flags(0), _atomflags(0) {
   this->_alignment = 0;
   this->_fsize = 0;
-  _outputMagic = context.getOutputMagic();
+  _outputMagic = ctx.getOutputMagic();
 }
 
 // This function actually is used, but not in all instantiations of Segment.
@@ -419,8 +419,8 @@
   uint64_t fileOffset = startOffset;
   uint64_t curSliceFileOffset = fileOffset;
   bool isDataPageAlignedForNMagic = false;
-  bool alignSegments = this->_context.alignSegments();
-  uint64_t p_align = this->_context.getPageSize();
+  bool alignSegments = this->_ctx.alignSegments();
+  uint64_t p_align = this->_ctx.getPageSize();
   uint64_t lastVirtualAddress = 0;
 
   this->setFileOffset(startOffset);
@@ -455,7 +455,7 @@
         }
       } else if (!isDataPageAlignedForNMagic && needAlign(section)) {
         fileOffset =
-            llvm::RoundUpToAlignment(fileOffset, this->_context.getPageSize());
+            llvm::RoundUpToAlignment(fileOffset, this->_ctx.getPageSize());
         isDataPageAlignedForNMagic = true;
       }
       if (isFirstSection) {
@@ -493,7 +493,7 @@
   uint64_t startAddr = addr;
   SegmentSlice<ELFT> *slice = nullptr;
   uint64_t tlsStartAddr = 0;
-  bool alignSegments = this->_context.alignSegments();
+  bool alignSegments = this->_ctx.alignSegments();
   StringRef prevOutputSectionName = StringRef();
 
   for (auto si = _sections.begin(); si != _sections.end(); ++si) {
@@ -508,12 +508,12 @@
         // Align to a page only if the output is not
         // OutputMagic::NMAGIC/OutputMagic::OMAGIC
         startAddr =
-            llvm::RoundUpToAlignment(startAddr, this->_context.getPageSize());
+            llvm::RoundUpToAlignment(startAddr, this->_ctx.getPageSize());
       else if (!isDataPageAlignedForNMagic && needAlign(*si)) {
         // If the linker outputmagic is set to OutputMagic::NMAGIC, align the
         // Data to a page boundary.
         startAddr =
-            llvm::RoundUpToAlignment(startAddr, this->_context.getPageSize());
+            llvm::RoundUpToAlignment(startAddr, this->_ctx.getPageSize());
         isDataPageAlignedForNMagic = true;
       }
       // align the startOffset to the section alignment
@@ -549,8 +549,7 @@
         // If the linker outputmagic is set to OutputMagic::NMAGIC, align the
         // Data
         // to a page boundary
-        curAddr =
-            llvm::RoundUpToAlignment(curAddr, this->_context.getPageSize());
+        curAddr = llvm::RoundUpToAlignment(curAddr, this->_ctx.getPageSize());
         isDataPageAlignedForNMagic = true;
       }
       uint64_t newAddr = llvm::RoundUpToAlignment(curAddr, (*si)->alignment());
@@ -577,8 +576,7 @@
       // 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 =
Index: lib/ReaderWriter/ELF/TargetLayout.h
===================================================================
--- lib/ReaderWriter/ELF/TargetLayout.h
+++ lib/ReaderWriter/ELF/TargetLayout.h
@@ -20,7 +20,7 @@
 /// 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
Index: lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h
@@ -18,7 +18,7 @@
 template <class ELFT>
 class X86DynamicLibraryWriter : public DynamicLibraryWriter<ELFT> {
 public:
-  X86DynamicLibraryWriter(X86LinkingContext &context,
+  X86DynamicLibraryWriter(X86LinkingContext &ctx,
                           X86TargetLayout<ELFT> &layout);
 
 protected:
@@ -41,15 +41,15 @@
   };
 
   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(
Index: lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h
+++ lib/ReaderWriter/ELF/X86/X86ExecutableWriter.h
@@ -18,8 +18,7 @@
 template <class ELFT>
 class X86ExecutableWriter : public ExecutableWriter<ELFT> {
 public:
-  X86ExecutableWriter(X86LinkingContext &context,
-                      X86TargetLayout<ELFT> &layout);
+  X86ExecutableWriter(X86LinkingContext &ctx, X86TargetLayout<ELFT> &layout);
 
 protected:
   // Add any runtime files and their atoms to the output
@@ -34,15 +33,14 @@
   }
 
 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(
Index: lib/ReaderWriter/ELF/X86/X86TargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/X86/X86TargetHandler.h
+++ lib/ReaderWriter/ELF/X86/X86TargetHandler.h
@@ -23,13 +23,13 @@
 
 template <class ELFT> class X86TargetLayout : public TargetLayout<ELFT> {
 public:
-  X86TargetLayout(X86LinkingContext &context) : TargetLayout<ELFT>(context) {}
+  X86TargetLayout(X86LinkingContext &ctx) : TargetLayout<ELFT>(ctx) {}
 };
 
 class X86TargetHandler final
     : public DefaultTargetHandler<X86ELFType> {
 public:
-  X86TargetHandler(X86LinkingContext &context);
+  X86TargetHandler(X86LinkingContext &ctx);
 
   X86TargetLayout<X86ELFType> &getTargetLayout() override {
     return *(_x86TargetLayout.get());
@@ -42,18 +42,18 @@
   }
 
   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;
 };
Index: lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp
===================================================================
--- lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp
+++ lib/ReaderWriter/ELF/X86/X86TargetHandler.cpp
@@ -19,13 +19,13 @@
 using namespace llvm::ELF;
 
 std::unique_ptr<Writer> X86TargetHandler::getWriter() {
-  switch (_x86LinkingContext.getOutputELFType()) {
+  switch (_ctx.getOutputELFType()) {
   case llvm::ELF::ET_EXEC:
     return llvm::make_unique<X86ExecutableWriter<X86ELFType>>(
-        _x86LinkingContext, *_x86TargetLayout.get());
+        _ctx, *_x86TargetLayout.get());
   case llvm::ELF::ET_DYN:
     return llvm::make_unique<X86DynamicLibraryWriter<X86ELFType>>(
-        _x86LinkingContext, *_x86TargetLayout.get());
+        _ctx, *_x86TargetLayout.get());
   case llvm::ELF::ET_REL:
     llvm_unreachable("TODO: support -r mode");
   default:
@@ -47,7 +47,6 @@
                         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()) {}
Index: lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h
===================================================================
--- lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h
+++ lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h
@@ -19,7 +19,7 @@
 
 class X86_64DynamicLibraryWriter : public DynamicLibraryWriter<X86_64ELFType> {
 public:
-  X86_64DynamicLibraryWriter(X86_64LinkingContext &context,
+  X86_64DynamicLibraryWriter(X86_64LinkingContext &ctx,
                              X86_64TargetLayout &layout);
 
 protected:
@@ -45,8 +45,8 @@
 };
 
 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) {
Index: lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h
===================================================================
--- lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h
+++ lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h
@@ -18,10 +18,8 @@
 
 class X86_64ExecutableWriter : public ExecutableWriter<X86_64ELFType> {
 public:
-  X86_64ExecutableWriter(X86_64LinkingContext &context,
-                         X86_64TargetLayout &layout)
-      : ExecutableWriter(context, layout), _gotFile(new GOTFile(context)),
-        _context(context) {}
+  X86_64ExecutableWriter(X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
+      : ExecutableWriter(ctx, layout), _gotFile(new GOTFile(ctx)), _ctx(ctx) {}
 
 protected:
   // Add any runtime files and their atoms to the output
@@ -30,7 +28,7 @@
     ExecutableWriter::createImplicitFiles(result);
     _gotFile->addAtom(*new (_gotFile->_alloc)
                       GLOBAL_OFFSET_TABLEAtom(*_gotFile));
-    if (_context.isDynamic())
+    if (_ctx.isDynamic())
       _gotFile->addAtom(*new (_gotFile->_alloc) DYNAMICAtom(*_gotFile));
     result.push_back(std::move(_gotFile));
     return true;
@@ -52,7 +50,7 @@
   };
 
   std::unique_ptr<GOTFile> _gotFile;
-  X86_64LinkingContext &_context;
+  X86_64LinkingContext &_ctx;
 };
 
 } // namespace elf
Index: lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h
===================================================================
--- lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h
+++ lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.h
@@ -22,8 +22,7 @@
 namespace elf {
 class X86_64TargetLayout : public TargetLayout<X86_64ELFType> {
 public:
-  X86_64TargetLayout(X86_64LinkingContext &context)
-      : TargetLayout(context) {}
+  X86_64TargetLayout(X86_64LinkingContext &ctx) : TargetLayout(ctx) {}
 
   void finalizeOutputSectionLayout() override {
     sortOutputSectionByPriority(".init_array", ".init_array");
@@ -34,7 +33,7 @@
 class X86_64TargetHandler
     : public DefaultTargetHandler<X86_64ELFType> {
 public:
-  X86_64TargetHandler(X86_64LinkingContext &context);
+  X86_64TargetHandler(X86_64LinkingContext &ctx);
 
   X86_64TargetLayout &getTargetLayout() override {
     return *(_x86_64TargetLayout.get());
@@ -47,18 +46,18 @@
   }
 
   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;
 };
Index: lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp
===================================================================
--- lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp
+++ lib/ReaderWriter/ELF/X86_64/X86_64TargetHandler.cpp
@@ -16,8 +16,8 @@
 using namespace lld;
 using namespace elf;
 
-X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &context)
-    : _context(context), _x86_64TargetLayout(new X86_64TargetLayout(context)),
+X86_64TargetHandler::X86_64TargetHandler(X86_64LinkingContext &ctx)
+    : _ctx(ctx), _x86_64TargetLayout(new X86_64TargetLayout(ctx)),
       _x86_64RelocationHandler(
           new X86_64TargetRelocationHandler(*_x86_64TargetLayout.get())) {}
 
@@ -27,13 +27,13 @@
 }
 
 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: