Index: ELF/CMakeLists.txt
===================================================================
--- ELF/CMakeLists.txt
+++ ELF/CMakeLists.txt
@@ -10,7 +10,7 @@
   InputSection.cpp
   LinkerScript.cpp
   MarkLive.cpp
-  OutputSections.cpp
+  Segments.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
Index: ELF/Config.h
===================================================================
--- ELF/Config.h
+++ ELF/Config.h
@@ -43,7 +43,7 @@
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
-  llvm::MapVector<llvm::StringRef, std::vector<llvm::StringRef>> OutputSections;
+  llvm::MapVector<llvm::StringRef, std::vector<llvm::StringRef>> Segments;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   bool AllowMultipleDefinition;
Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -18,8 +18,8 @@
 namespace elf2 {
 
 template <class ELFT> class ObjectFile;
-template <class ELFT> class OutputSection;
-template <class ELFT> class OutputSectionBase;
+template <class ELFT> class Segment;
+template <class ELFT> class SegmentBase;
 
 // This corresponds to a section of an input file.
 template <class ELFT> class InputSectionBase {
@@ -40,7 +40,7 @@
 
   InputSectionBase(ObjectFile<ELFT> *File, const Elf_Shdr *Header,
                    Kind SectionKind);
-  OutputSectionBase<ELFT> *OutSec = nullptr;
+  SegmentBase<ELFT> *Segm = nullptr;
 
   // Used for garbage collection.
   // Live bit makes sense only when Config->GcSections is true.
@@ -156,7 +156,7 @@
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
-  uint64_t OutSecOff = 0;
+  uint64_t SegmOff = 0;
 
   static bool classof(const InputSectionBase<ELFT> *S);
 };
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -11,7 +11,7 @@
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Target.h"
 
 using namespace llvm;
@@ -46,7 +46,7 @@
 InputSectionBase<ELFT>::getOffset(uintX_t Offset) {
   switch (SectionKind) {
   case Regular:
-    return cast<InputSection<ELFT>>(this)->OutSecOff + Offset;
+    return cast<InputSection<ELFT>>(this)->SegmOff + Offset;
   case EHFrame:
     return cast<EHInputSection<ELFT>>(this)->getOffset(Offset);
   case Merge:
@@ -150,7 +150,7 @@
       continue;
 
     uint8_t *BufLoc = Buf + Offset;
-    uintX_t AddrLoc = OutSec->getVA() + Offset;
+    uintX_t AddrLoc = Segm->getVA() + Offset;
     auto NextRelocs = llvm::make_range(&RI, Rels.end());
 
     if (Target->isTlsLocalDynamicReloc(Type) &&
@@ -231,10 +231,10 @@
     return;
   // Copy section contents from source object file to output file.
   ArrayRef<uint8_t> Data = this->getSectionData();
-  memcpy(Buf + OutSecOff, Data.data(), Data.size());
+  memcpy(Buf + SegmOff, Data.data(), Data.size());
 
   ELFFile<ELFT> &EObj = this->File->getObj();
-  uint8_t *BufEnd = Buf + OutSecOff + Data.size();
+  uint8_t *BufEnd = Buf + SegmOff + Data.size();
   // Iterate over all relocation sections that apply to this section.
   for (const Elf_Shdr *RelSec : this->RelocSections) {
     if (RelSec->sh_type == SHT_RELA)
@@ -323,8 +323,7 @@
   ArrayRef<uint8_t> D = this->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   StringRef Entry = Data.substr(Start, End - Start);
-  Base =
-      static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(Entry);
+  Base = static_cast<MergeSegment<ELFT> *>(this->Segm)->getOffset(Entry);
   return Base + Addend;
 }
 
Index: ELF/LinkerScript.cpp
===================================================================
--- ELF/LinkerScript.cpp
+++ ELF/LinkerScript.cpp
@@ -53,7 +53,7 @@
   void readSearchDir();
   void readSections();
 
-  void readOutputSectionDescription();
+  void readSegmentDescription();
 
   StringSaver Saver;
   std::vector<StringRef> Tokens;
@@ -285,12 +285,12 @@
 void LinkerScript::readSections() {
   expect("{");
   while (!skip("}"))
-    readOutputSectionDescription();
+    readSegmentDescription();
 }
 
-void LinkerScript::readOutputSectionDescription() {
+void LinkerScript::readSegmentDescription() {
   StringRef Name = next();
-  std::vector<StringRef> &InputSections = Config->OutputSections[Name];
+  std::vector<StringRef> &InputSections = Config->Segments[Name];
 
   expect(":");
   expect("{");
Index: ELF/MarkLive.cpp
===================================================================
--- ELF/MarkLive.cpp
+++ ELF/MarkLive.cpp
@@ -21,7 +21,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "InputSection.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
Index: ELF/Segments.h
===================================================================
--- ELF/Segments.h
+++ ELF/Segments.h
@@ -1,4 +1,4 @@
-//===- OutputSections.h -----------------------------------------*- C++ -*-===//
+//===- Segments.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
@@ -32,7 +32,7 @@
 template <class ELFT> class InputSectionBase;
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class MipsReginfoInputSection;
-template <class ELFT> class OutputSection;
+template <class ELFT> class Segment;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class DefinedRegular;
 
@@ -72,14 +72,14 @@
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
-// The writer creates multiple OutputSections and assign them unique,
+// The writer creates multiple Segments and assign them unique,
 // non-overlapping file offsets and VAs.
-template <class ELFT> class OutputSectionBase {
+template <class ELFT> class SegmentBase {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
 
-  OutputSectionBase(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  SegmentBase(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void setVA(uintX_t VA) { Header.sh_addr = VA; }
   uintX_t getVA() const { return Header.sh_addr; }
   void setFileOffset(uintX_t Off) { Header.sh_offset = Off; }
@@ -110,11 +110,11 @@
 protected:
   StringRef Name;
   Elf_Shdr Header;
-  ~OutputSectionBase() = default;
+  ~SegmentBase() = default;
 };
 
-template <class ELFT> class GotSection final : public OutputSectionBase<ELFT> {
-  typedef OutputSectionBase<ELFT> Base;
+template <class ELFT> class GotSection final : public SegmentBase<ELFT> {
+  typedef SegmentBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
@@ -146,8 +146,7 @@
   uint32_t LocalTlsIndexOff = -1;
 };
 
-template <class ELFT>
-class GotPltSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class GotPltSection final : public SegmentBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
 
 public:
@@ -162,8 +161,8 @@
   std::vector<const SymbolBody *> Entries;
 };
 
-template <class ELFT> class PltSection final : public OutputSectionBase<ELFT> {
-  typedef OutputSectionBase<ELFT> Base;
+template <class ELFT> class PltSection final : public SegmentBase<ELFT> {
+  typedef SegmentBase<ELFT> Base;
   typedef typename Base::uintX_t uintX_t;
 
 public:
@@ -185,7 +184,7 @@
 };
 
 template <class ELFT>
-class SymbolTableSection final : public OutputSectionBase<ELFT> {
+class SymbolTableSection final : public SegmentBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
@@ -216,8 +215,7 @@
   unsigned NumLocals = 0;
 };
 
-template <class ELFT>
-class RelocationSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class RelocationSection final : public SegmentBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
@@ -241,15 +239,14 @@
   const bool IsRela;
 };
 
-template <class ELFT>
-class OutputSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class Segment final : public SegmentBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
-  OutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  Segment(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void addSection(InputSection<ELFT> *C);
   void writeTo(uint8_t *Buf) override;
 
@@ -257,14 +254,13 @@
   std::vector<InputSection<ELFT> *> Sections;
 };
 
-template <class ELFT>
-class MergeOutputSection final : public OutputSectionBase<ELFT> {
-  typedef typename OutputSectionBase<ELFT>::uintX_t uintX_t;
+template <class ELFT> class MergeSegment final : public SegmentBase<ELFT> {
+  typedef typename SegmentBase<ELFT>::uintX_t uintX_t;
 
   bool shouldTailMerge() const;
 
 public:
-  MergeOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  MergeSegment(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void addSection(MergeInputSection<ELFT> *S);
   void writeTo(uint8_t *Buf) override;
   unsigned getOffset(StringRef Val);
@@ -288,14 +284,13 @@
   std::vector<EHRegion<ELFT>> Fdes;
 };
 
-template <class ELFT>
-class EHOutputSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class EHSegment final : public SegmentBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
-  EHOutputSection(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
+  EHSegment(StringRef Name, uint32_t sh_type, uintX_t sh_flags);
   void writeTo(uint8_t *Buf) override;
 
   template <bool IsRela>
@@ -316,15 +311,14 @@
   llvm::DenseMap<std::pair<StringRef, StringRef>, unsigned> CieMap;
 };
 
-template <class ELFT>
-class InterpSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class InterpSection final : public SegmentBase<ELFT> {
 public:
   InterpSection();
   void writeTo(uint8_t *Buf) override;
 };
 
 template <class ELFT>
-class StringTableSection final : public OutputSectionBase<ELFT> {
+class StringTableSection final : public SegmentBase<ELFT> {
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   StringTableSection(StringRef Name, bool Dynamic);
@@ -345,8 +339,7 @@
   llvm::StringTableBuilder StrTabBuilder{llvm::StringTableBuilder::ELF};
 };
 
-template <class ELFT>
-class HashTableSection final : public OutputSectionBase<ELFT> {
+template <class ELFT> class HashTableSection final : public SegmentBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
 
 public:
@@ -358,7 +351,7 @@
 // Outputs GNU Hash section. For detailed explanation see:
 // https://blogs.oracle.com/ali/entry/gnu_hash_elf_sections
 template <class ELFT>
-class GnuHashTableSection final : public OutputSectionBase<ELFT> {
+class GnuHashTableSection final : public SegmentBase<ELFT> {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Off Elf_Off;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Word Elf_Word;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
@@ -392,9 +385,8 @@
   unsigned Shift2;
 };
 
-template <class ELFT>
-class DynamicSection final : public OutputSectionBase<ELFT> {
-  typedef OutputSectionBase<ELFT> Base;
+template <class ELFT> class DynamicSection final : public SegmentBase<ELFT> {
+  typedef SegmentBase<ELFT> Base;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Dyn Elf_Dyn;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rela Elf_Rela;
@@ -406,9 +398,9 @@
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
 
-  OutputSectionBase<ELFT> *PreInitArraySec = nullptr;
-  OutputSectionBase<ELFT> *InitArraySec = nullptr;
-  OutputSectionBase<ELFT> *FiniArraySec = nullptr;
+  SegmentBase<ELFT> *PreInitArraySec = nullptr;
+  SegmentBase<ELFT> *InitArraySec = nullptr;
+  SegmentBase<ELFT> *FiniArraySec = nullptr;
 
 private:
   SymbolTable<ELFT> &SymTab;
@@ -419,11 +411,11 @@
 };
 
 template <class ELFT>
-class MipsReginfoOutputSection final : public OutputSectionBase<ELFT> {
+class MipsReginfoSegment final : public SegmentBase<ELFT> {
   typedef llvm::object::Elf_Mips_RegInfo<ELFT> Elf_Mips_RegInfo;
 
 public:
-  MipsReginfoOutputSection();
+  MipsReginfoSegment();
   void writeTo(uint8_t *Buf) override;
 
   void addSection(MipsReginfoInputSection<ELFT> *S);
@@ -444,9 +436,9 @@
   static GotSection<ELFT> *Got;
   static HashTableSection<ELFT> *HashTab;
   static InterpSection<ELFT> *Interp;
-  static OutputSection<ELFT> *Bss;
-  static OutputSection<ELFT> *MipsRldMap;
-  static OutputSectionBase<ELFT> *Opd;
+  static Segment<ELFT> *Bss;
+  static Segment<ELFT> *MipsRldMap;
+  static SegmentBase<ELFT> *Opd;
   static uint8_t *OpdBuf;
   static PltSection<ELFT> *Plt;
   static RelocationSection<ELFT> *RelaDyn;
@@ -465,9 +457,9 @@
 template <class ELFT> GotSection<ELFT> *Out<ELFT>::Got;
 template <class ELFT> HashTableSection<ELFT> *Out<ELFT>::HashTab;
 template <class ELFT> InterpSection<ELFT> *Out<ELFT>::Interp;
-template <class ELFT> OutputSection<ELFT> *Out<ELFT>::Bss;
-template <class ELFT> OutputSection<ELFT> *Out<ELFT>::MipsRldMap;
-template <class ELFT> OutputSectionBase<ELFT> *Out<ELFT>::Opd;
+template <class ELFT> Segment<ELFT> *Out<ELFT>::Bss;
+template <class ELFT> Segment<ELFT> *Out<ELFT>::MipsRldMap;
+template <class ELFT> SegmentBase<ELFT> *Out<ELFT>::Opd;
 template <class ELFT> uint8_t *Out<ELFT>::OpdBuf;
 template <class ELFT> PltSection<ELFT> *Out<ELFT>::Plt;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaDyn;
Index: ELF/Segments.cpp
===================================================================
--- ELF/Segments.cpp
+++ ELF/Segments.cpp
@@ -1,4 +1,4 @@
-//===- OutputSections.cpp -------------------------------------------------===//
+//===- Segments.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
@@ -7,7 +7,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Config.h"
 #include "SymbolTable.h"
 #include "Target.h"
@@ -24,8 +24,8 @@
 bool lld::elf2::HasGotOffRel = false;
 
 template <class ELFT>
-OutputSectionBase<ELFT>::OutputSectionBase(StringRef Name, uint32_t sh_type,
-                                           uintX_t sh_flags)
+SegmentBase<ELFT>::SegmentBase(StringRef Name, uint32_t sh_type,
+                               uintX_t sh_flags)
     : Name(Name) {
   memset(&Header, 0, sizeof(Elf_Shdr));
   Header.sh_type = sh_type;
@@ -34,8 +34,8 @@
 
 template <class ELFT>
 GotPltSection<ELFT>::GotPltSection()
-    : OutputSectionBase<ELFT>(".got.plt", llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
+    : SegmentBase<ELFT>(".got.plt", llvm::ELF::SHT_PROGBITS,
+                        llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
@@ -70,8 +70,8 @@
 
 template <class ELFT>
 GotSection<ELFT>::GotSection()
-    : OutputSectionBase<ELFT>(".got", llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
+    : SegmentBase<ELFT>(".got", llvm::ELF::SHT_PROGBITS,
+                        llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE) {
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
   this->Header.sh_addralign = sizeof(uintX_t);
@@ -151,8 +151,8 @@
 
 template <class ELFT>
 PltSection<ELFT>::PltSection()
-    : OutputSectionBase<ELFT>(".plt", llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR) {
+    : SegmentBase<ELFT>(".plt", llvm::ELF::SHT_PROGBITS,
+                        llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_EXECINSTR) {
   this->Header.sh_addralign = 16;
 }
 
@@ -199,9 +199,8 @@
 
 template <class ELFT>
 RelocationSection<ELFT>::RelocationSection(StringRef Name, bool IsRela)
-    : OutputSectionBase<ELFT>(Name,
-                              IsRela ? llvm::ELF::SHT_RELA : llvm::ELF::SHT_REL,
-                              llvm::ELF::SHF_ALLOC),
+    : SegmentBase<ELFT>(Name, IsRela ? llvm::ELF::SHT_RELA : llvm::ELF::SHT_REL,
+                        llvm::ELF::SHF_ALLOC),
       IsRela(IsRela) {
   this->Header.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
@@ -223,8 +222,8 @@
     return false;
 
   if (Target->isTlsOptimized(Type, Body)) {
-    P->setSymbolAndType(Body->DynamicSymbolTableIndex,
-                        Target->getTlsGotReloc(), Config->Mips64EL);
+    P->setSymbolAndType(Body->DynamicSymbolTableIndex, Target->getTlsGotReloc(),
+                        Config->Mips64EL);
     P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
     return true;
   }
@@ -292,7 +291,7 @@
       P->r_offset = Out<ELFT>::Bss->getVA() +
                     dyn_cast<SharedSymbol<ELFT>>(Body)->OffsetInBSS;
     } else {
-      P->r_offset = C.getOffset(RI.r_offset) + C.OutSec->getVA();
+      P->r_offset = C.getOffset(RI.r_offset) + C.Segm->getVA();
     }
 
     uintX_t OrigAddend = 0;
@@ -331,14 +330,13 @@
 
 template <class ELFT>
 InterpSection<ELFT>::InterpSection()
-    : OutputSectionBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC) {
+    : SegmentBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
+                        llvm::ELF::SHF_ALLOC) {
   this->Header.sh_size = Config->DynamicLinker.size() + 1;
   this->Header.sh_addralign = 1;
 }
 
-template <class ELFT>
-void OutputSectionBase<ELFT>::writeHeaderTo(Elf_Shdr *SHdr) {
+template <class ELFT> void SegmentBase<ELFT>::writeHeaderTo(Elf_Shdr *SHdr) {
   Header.sh_name = Out<ELFT>::ShStrTab->getOffset(Name);
   *SHdr = Header;
 }
@@ -349,8 +347,7 @@
 
 template <class ELFT>
 HashTableSection<ELFT>::HashTableSection()
-    : OutputSectionBase<ELFT>(".hash", llvm::ELF::SHT_HASH,
-                              llvm::ELF::SHF_ALLOC) {
+    : SegmentBase<ELFT>(".hash", llvm::ELF::SHT_HASH, llvm::ELF::SHF_ALLOC) {
   this->Header.sh_entsize = sizeof(Elf_Word);
   this->Header.sh_addralign = sizeof(Elf_Word);
 }
@@ -370,7 +367,7 @@
 template <class ELFT> void HashTableSection<ELFT>::finalize() {
   this->Header.sh_link = Out<ELFT>::DynSymTab->SectionIndex;
 
-  unsigned NumEntries = 2;                 // nbucket and nchain.
+  unsigned NumEntries = 2;                             // nbucket and nchain.
   NumEntries += Out<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
 
   // Create as many buckets as there are symbols.
@@ -407,8 +404,8 @@
 
 template <class ELFT>
 GnuHashTableSection<ELFT>::GnuHashTableSection()
-    : OutputSectionBase<ELFT>(".gnu.hash", llvm::ELF::SHT_GNU_HASH,
-                              llvm::ELF::SHF_ALLOC) {
+    : SegmentBase<ELFT>(".gnu.hash", llvm::ELF::SHT_GNU_HASH,
+                        llvm::ELF::SHF_ALLOC) {
   this->Header.sh_entsize = ELFT::Is64Bits ? 0 : 4;
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
@@ -548,8 +545,8 @@
 
 template <class ELFT>
 DynamicSection<ELFT>::DynamicSection(SymbolTable<ELFT> &SymTab)
-    : OutputSectionBase<ELFT>(".dynamic", llvm::ELF::SHT_DYNAMIC,
-                              llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE),
+    : SegmentBase<ELFT>(".dynamic", llvm::ELF::SHT_DYNAMIC,
+                        llvm::ELF::SHF_ALLOC | llvm::ELF::SHF_WRITE),
       SymTab(SymTab) {
   Elf_Shdr &Header = this->Header;
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
@@ -717,8 +714,7 @@
   if (!Config->SoName.empty())
     WriteVal(DT_SONAME, Out<ELFT>::DynStrTab->getOffset(Config->SoName));
 
-  auto WriteArray = [&](int32_t T1, int32_t T2,
-                        const OutputSectionBase<ELFT> *Sec) {
+  auto WriteArray = [&](int32_t T1, int32_t T2, const SegmentBase<ELFT> *Sec) {
     if (!Sec)
       return;
     WritePtr(T1, Sec->getVA());
@@ -763,21 +759,19 @@
 }
 
 template <class ELFT>
-OutputSection<ELFT>::OutputSection(StringRef Name, uint32_t sh_type,
-                                   uintX_t sh_flags)
-    : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
+Segment<ELFT>::Segment(StringRef Name, uint32_t sh_type, uintX_t sh_flags)
+    : SegmentBase<ELFT>(Name, sh_type, sh_flags) {}
 
-template <class ELFT>
-void OutputSection<ELFT>::addSection(InputSection<ELFT> *C) {
+template <class ELFT> void Segment<ELFT>::addSection(InputSection<ELFT> *C) {
   Sections.push_back(C);
-  C->OutSec = this;
+  C->Segm = this;
   uint32_t Align = C->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
 
   uintX_t Off = this->Header.sh_size;
   Off = RoundUpToAlignment(Off, Align);
-  C->OutSecOff = Off;
+  C->SegmOff = Off;
   Off += C->getSize();
   this->Header.sh_size = Off;
 }
@@ -787,7 +781,7 @@
   switch (S.kind()) {
   case SymbolBody::DefinedSyntheticKind: {
     auto &D = cast<DefinedSynthetic<ELFT>>(S);
-    return D.Section.getVA() + D.Value;
+    return D.Segm.getVA() + D.Value;
   }
   case SymbolBody::DefinedAbsoluteKind:
     return cast<DefinedAbsolute<ELFT>>(S).Sym.st_value;
@@ -795,9 +789,9 @@
     const auto &DR = cast<DefinedRegular<ELFT>>(S);
     InputSectionBase<ELFT> &SC = DR.Section;
     if (DR.Sym.getType() == STT_TLS)
-      return SC.OutSec->getVA() + SC.getOffset(DR.Sym) -
+      return SC.Segm->getVA() + SC.getOffset(DR.Sym) -
              Out<ELFT>::TlsPhdr->p_vaddr;
-    return SC.OutSec->getVA() + SC.getOffset(DR.Sym);
+    return SC.Segm->getVA() + SC.getOffset(DR.Sym);
   }
   case SymbolBody::DefinedCommonKind:
     return Out<ELFT>::Bss->getVA() + cast<DefinedCommon<ELFT>>(S).OffsetInBSS;
@@ -841,7 +835,7 @@
   InputSectionBase<ELFT> *Section = File.getSection(*Sym);
 
   if (Sym->getType() == STT_TLS)
-    return (Section->OutSec->getVA() + Section->getOffset(*Sym) + Addend) -
+    return (Section->Segm->getVA() + Section->getOffset(*Sym) + Addend) -
            Out<ELFT>::TlsPhdr->p_vaddr;
 
   // According to the ELF spec reference to a local symbol from outside
@@ -851,7 +845,7 @@
   if (Section == &InputSection<ELFT>::Discarded || !Section->isLive())
     return Addend;
 
-  uintX_t VA = Section->OutSec->getVA();
+  uintX_t VA = Section->Segm->getVA();
   if (isa<InputSection<ELFT>>(Section))
     return VA + Section->getOffset(*Sym) + Addend;
 
@@ -868,7 +862,7 @@
 // with the same name defined in other ELF executable or DSO.
 bool lld::elf2::canBePreempted(const SymbolBody *Body, bool NeedsGot) {
   if (!Body)
-    return false;  // Body is a local symbol.
+    return false; // Body is a local symbol.
   if (Body->isShared())
     return true;
 
@@ -902,15 +896,14 @@
   return Body->getVisibility() == STV_DEFAULT;
 }
 
-template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
+template <class ELFT> void Segment<ELFT>::writeTo(uint8_t *Buf) {
   for (InputSection<ELFT> *C : Sections)
     C->writeTo(Buf);
 }
 
 template <class ELFT>
-EHOutputSection<ELFT>::EHOutputSection(StringRef Name, uint32_t sh_type,
-                                       uintX_t sh_flags)
-    : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
+EHSegment<ELFT>::EHSegment(StringRef Name, uint32_t sh_type, uintX_t sh_flags)
+    : SegmentBase<ELFT>(Name, sh_type, sh_flags) {}
 
 template <class ELFT>
 EHRegion<ELFT>::EHRegion(EHInputSection<ELFT> *S, unsigned Index)
@@ -931,12 +924,12 @@
 
 template <class ELFT>
 template <bool IsRela>
-void EHOutputSection<ELFT>::addSectionAux(
+void EHSegment<ELFT>::addSectionAux(
     EHInputSection<ELFT> *S,
     iterator_range<const Elf_Rel_Impl<ELFT, IsRela> *> Rels) {
   const endianness E = ELFT::TargetEndianness;
 
-  S->OutSec = this;
+  S->Segm = this;
   uint32_t Align = S->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
@@ -1001,8 +994,8 @@
 }
 
 template <class ELFT>
-typename EHOutputSection<ELFT>::uintX_t
-EHOutputSection<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
+typename EHSegment<ELFT>::uintX_t
+EHSegment<ELFT>::readEntryLength(ArrayRef<uint8_t> D) {
   const endianness E = ELFT::TargetEndianness;
 
   if (D.size() < 4)
@@ -1027,7 +1020,7 @@
 }
 
 template <class ELFT>
-void EHOutputSection<ELFT>::addSection(EHInputSection<ELFT> *S) {
+void EHSegment<ELFT>::addSection(EHInputSection<ELFT> *S) {
   const Elf_Shdr *RelSec = S->RelocSection;
   if (!RelSec)
     return addSectionAux(
@@ -1038,7 +1031,7 @@
   return addSectionAux(S, Obj.rels(RelSec));
 }
 
-template <class ELFT> void EHOutputSection<ELFT>::writeTo(uint8_t *Buf) {
+template <class ELFT> void EHSegment<ELFT>::writeTo(uint8_t *Buf) {
   const endianness E = ELFT::TargetEndianness;
   size_t Offset = 0;
   for (const Cie<ELFT> &C : Cies) {
@@ -1073,11 +1066,11 @@
 }
 
 template <class ELFT>
-MergeOutputSection<ELFT>::MergeOutputSection(StringRef Name, uint32_t sh_type,
-                                             uintX_t sh_flags)
-    : OutputSectionBase<ELFT>(Name, sh_type, sh_flags) {}
+MergeSegment<ELFT>::MergeSegment(StringRef Name, uint32_t sh_type,
+                                 uintX_t sh_flags)
+    : SegmentBase<ELFT>(Name, sh_type, sh_flags) {}
 
-template <class ELFT> void MergeOutputSection<ELFT>::writeTo(uint8_t *Buf) {
+template <class ELFT> void MergeSegment<ELFT>::writeTo(uint8_t *Buf) {
   if (shouldTailMerge()) {
     StringRef Data = Builder.data();
     memcpy(Buf, Data.data(), Data.size());
@@ -1103,8 +1096,8 @@
 }
 
 template <class ELFT>
-void MergeOutputSection<ELFT>::addSection(MergeInputSection<ELFT> *S) {
-  S->OutSec = this;
+void MergeSegment<ELFT>::addSection(MergeInputSection<ELFT> *S) {
+  S->Segm = this;
   uint32_t Align = S->getAlign();
   if (Align > this->Header.sh_addralign)
     this->Header.sh_addralign = Align;
@@ -1138,16 +1131,15 @@
   }
 }
 
-template <class ELFT>
-unsigned MergeOutputSection<ELFT>::getOffset(StringRef Val) {
+template <class ELFT> unsigned MergeSegment<ELFT>::getOffset(StringRef Val) {
   return Builder.getOffset(Val);
 }
 
-template <class ELFT> bool MergeOutputSection<ELFT>::shouldTailMerge() const {
+template <class ELFT> bool MergeSegment<ELFT>::shouldTailMerge() const {
   return Config->Optimize >= 2 && this->Header.sh_flags & SHF_STRINGS;
 }
 
-template <class ELFT> void MergeOutputSection<ELFT>::finalize() {
+template <class ELFT> void MergeSegment<ELFT>::finalize() {
   if (shouldTailMerge())
     Builder.finalize();
   this->Header.sh_size = Builder.getSize();
@@ -1155,8 +1147,8 @@
 
 template <class ELFT>
 StringTableSection<ELFT>::StringTableSection(StringRef Name, bool Dynamic)
-    : OutputSectionBase<ELFT>(Name, llvm::ELF::SHT_STRTAB,
-                              Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
+    : SegmentBase<ELFT>(Name, llvm::ELF::SHT_STRTAB,
+                        Dynamic ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
       Dynamic(Dynamic) {
   this->Header.sh_addralign = 1;
 }
@@ -1208,12 +1200,12 @@
 template <class ELFT>
 SymbolTableSection<ELFT>::SymbolTableSection(
     SymbolTable<ELFT> &Table, StringTableSection<ELFT> &StrTabSec)
-    : OutputSectionBase<ELFT>(
+    : SegmentBase<ELFT>(
           StrTabSec.isDynamic() ? ".dynsym" : ".symtab",
           StrTabSec.isDynamic() ? llvm::ELF::SHT_DYNSYM : llvm::ELF::SHT_SYMTAB,
           StrTabSec.isDynamic() ? (uintX_t)llvm::ELF::SHF_ALLOC : 0),
       Table(Table), StrTabSec(StrTabSec) {
-  typedef OutputSectionBase<ELFT> Base;
+  typedef SegmentBase<ELFT> Base;
   typename Base::Elf_Shdr &Header = this->Header;
 
   Header.sh_entsize = sizeof(Elf_Sym);
@@ -1304,9 +1296,9 @@
         InputSectionBase<ELFT> *Section = File->getSection(Sym);
         if (!Section->isLive())
           continue;
-        const OutputSectionBase<ELFT> *OutSec = Section->OutSec;
-        ESym->st_shndx = OutSec->SectionIndex;
-        VA += OutSec->getVA() + Section->getOffset(Sym);
+        const SegmentBase<ELFT> *Segm = Section->Segm;
+        ESym->st_shndx = Segm->SectionIndex;
+        VA += Segm->getVA() + Section->getOffset(Sym);
       }
       ESym->st_name = StrTabSec.getOffset(SymName);
       ESym->st_size = Sym.st_size;
@@ -1333,25 +1325,25 @@
   // pointed by Buf.
   auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
   for (SymbolBody *Body : Symbols) {
-    const OutputSectionBase<ELFT> *OutSec = nullptr;
+    const SegmentBase<ELFT> *Segm = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedSyntheticKind:
-      OutSec = &cast<DefinedSynthetic<ELFT>>(Body)->Section;
+      Segm = &cast<DefinedSynthetic<ELFT>>(Body)->Segm;
       break;
     case SymbolBody::DefinedRegularKind: {
       auto *Sym = cast<DefinedRegular<ELFT>>(Body->repl());
       if (!Sym->Section.isLive())
         continue;
-      OutSec = Sym->Section.OutSec;
+      Segm = Sym->Section.Segm;
       break;
     }
     case SymbolBody::DefinedCommonKind:
-      OutSec = Out<ELFT>::Bss;
+      Segm = Out<ELFT>::Bss;
       break;
     case SymbolBody::SharedKind: {
       if (cast<SharedSymbol<ELFT>>(Body)->NeedsCopy)
-        OutSec = Out<ELFT>::Bss;
+        Segm = Out<ELFT>::Bss;
       break;
     }
     case SymbolBody::UndefinedElfKind:
@@ -1378,8 +1370,8 @@
 
     if (isa<DefinedAbsolute<ELFT>>(Body))
       ESym->st_shndx = SHN_ABS;
-    else if (OutSec)
-      ESym->st_shndx = OutSec->SectionIndex;
+    else if (Segm)
+      ESym->st_shndx = Segm->SectionIndex;
 
     ++ESym;
   }
@@ -1398,32 +1390,30 @@
 }
 
 template <class ELFT>
-MipsReginfoOutputSection<ELFT>::MipsReginfoOutputSection()
-    : OutputSectionBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
+MipsReginfoSegment<ELFT>::MipsReginfoSegment()
+    : SegmentBase<ELFT>(".reginfo", SHT_MIPS_REGINFO, SHF_ALLOC) {
   this->Header.sh_addralign = 4;
   this->Header.sh_entsize = sizeof(Elf_Mips_RegInfo);
   this->Header.sh_size = sizeof(Elf_Mips_RegInfo);
 }
 
-template <class ELFT>
-void MipsReginfoOutputSection<ELFT>::writeTo(uint8_t *Buf) {
+template <class ELFT> void MipsReginfoSegment<ELFT>::writeTo(uint8_t *Buf) {
   auto *R = reinterpret_cast<Elf_Mips_RegInfo *>(Buf);
   R->ri_gp_value = getMipsGpAddr<ELFT>();
   R->ri_gprmask = GeneralMask;
 }
 
 template <class ELFT>
-void MipsReginfoOutputSection<ELFT>::addSection(
-    MipsReginfoInputSection<ELFT> *S) {
+void MipsReginfoSegment<ELFT>::addSection(MipsReginfoInputSection<ELFT> *S) {
   GeneralMask |= S->getGeneralMask();
 }
 
 namespace lld {
 namespace elf2 {
-template class OutputSectionBase<ELF32LE>;
-template class OutputSectionBase<ELF32BE>;
-template class OutputSectionBase<ELF64LE>;
-template class OutputSectionBase<ELF64BE>;
+template class SegmentBase<ELF32LE>;
+template class SegmentBase<ELF32BE>;
+template class SegmentBase<ELF64LE>;
+template class SegmentBase<ELF64BE>;
 
 template class GotPltSection<ELF32LE>;
 template class GotPltSection<ELF32BE>;
@@ -1465,25 +1455,25 @@
 template class DynamicSection<ELF64LE>;
 template class DynamicSection<ELF64BE>;
 
-template class OutputSection<ELF32LE>;
-template class OutputSection<ELF32BE>;
-template class OutputSection<ELF64LE>;
-template class OutputSection<ELF64BE>;
-
-template class EHOutputSection<ELF32LE>;
-template class EHOutputSection<ELF32BE>;
-template class EHOutputSection<ELF64LE>;
-template class EHOutputSection<ELF64BE>;
-
-template class MipsReginfoOutputSection<ELF32LE>;
-template class MipsReginfoOutputSection<ELF32BE>;
-template class MipsReginfoOutputSection<ELF64LE>;
-template class MipsReginfoOutputSection<ELF64BE>;
-
-template class MergeOutputSection<ELF32LE>;
-template class MergeOutputSection<ELF32BE>;
-template class MergeOutputSection<ELF64LE>;
-template class MergeOutputSection<ELF64BE>;
+template class Segment<ELF32LE>;
+template class Segment<ELF32BE>;
+template class Segment<ELF64LE>;
+template class Segment<ELF64BE>;
+
+template class EHSegment<ELF32LE>;
+template class EHSegment<ELF32BE>;
+template class EHSegment<ELF64LE>;
+template class EHSegment<ELF64BE>;
+
+template class MipsReginfoSegment<ELF32LE>;
+template class MipsReginfoSegment<ELF32BE>;
+template class MipsReginfoSegment<ELF64LE>;
+template class MipsReginfoSegment<ELF64BE>;
+
+template class MergeSegment<ELF32LE>;
+template class MergeSegment<ELF32BE>;
+template class MergeSegment<ELF64LE>;
+template class MergeSegment<ELF64BE>;
 
 template class StringTableSection<ELF32LE>;
 template class StringTableSection<ELF32BE>;
Index: ELF/SymbolTable.h
===================================================================
--- ELF/SymbolTable.h
+++ ELF/SymbolTable.h
@@ -16,7 +16,7 @@
 namespace lld {
 namespace elf2 {
 class Lazy;
-template <class ELFT> class OutputSectionBase;
+template <class ELFT> class SegmentBase;
 struct Symbol;
 class Undefined;
 
@@ -52,7 +52,7 @@
   SymbolBody *addUndefinedOpt(StringRef Name);
   void addAbsolute(StringRef Name,
                    typename llvm::object::ELFFile<ELFT>::Elf_Sym &ESym);
-  void addSynthetic(StringRef Name, OutputSectionBase<ELFT> &Section,
+  void addSynthetic(StringRef Name, SegmentBase<ELFT> &Segm,
                     typename llvm::object::ELFFile<ELFT>::uintX_t Value);
   SymbolBody *addIgnored(StringRef Name);
   bool isUndefined(StringRef Name);
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -99,10 +99,9 @@
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::addSynthetic(StringRef Name,
-                                     OutputSectionBase<ELFT> &Section,
+void SymbolTable<ELFT>::addSynthetic(StringRef Name, SegmentBase<ELFT> &Segm,
                                      typename ELFFile<ELFT>::uintX_t Value) {
-  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Value, Section);
+  auto *Sym = new (Alloc) DefinedSynthetic<ELFT>(Name, Value, Segm);
   resolve(Sym);
 }
 
Index: ELF/Symbols.h
===================================================================
--- ELF/Symbols.h
+++ ELF/Symbols.h
@@ -36,8 +36,8 @@
 class InputFile;
 class SymbolBody;
 template <class ELFT> class ObjectFile;
-template <class ELFT> class OutputSection;
-template <class ELFT> class OutputSectionBase;
+template <class ELFT> class Segment;
+template <class ELFT> class SegmentBase;
 template <class ELFT> class SharedFile;
 
 // Initializes global objects defined in this file.
@@ -246,15 +246,14 @@
 public:
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
-  DefinedSynthetic(StringRef N, uintX_t Value,
-                   OutputSectionBase<ELFT> &Section);
+  DefinedSynthetic(StringRef N, uintX_t Value, SegmentBase<ELFT> &Segm);
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedSyntheticKind;
   }
 
   uintX_t Value;
-  const OutputSectionBase<ELFT> &Section;
+  const SegmentBase<ELFT> &Segm;
 };
 
 // Undefined symbol.
Index: ELF/Symbols.cpp
===================================================================
--- ELF/Symbols.cpp
+++ ELF/Symbols.cpp
@@ -97,9 +97,9 @@
 
 template <typename ELFT>
 DefinedSynthetic<ELFT>::DefinedSynthetic(StringRef N, uintX_t Value,
-                                         OutputSectionBase<ELFT> &Section)
+                                         SegmentBase<ELFT> &Segm)
     : Defined(SymbolBody::DefinedSyntheticKind, N, false, STV_DEFAULT, false),
-      Value(Value), Section(Section) {}
+      Value(Value), Segm(Segm) {}
 
 std::unique_ptr<InputFile> Lazy::getMember() {
   MemoryBufferRef MBRef = File->getMember(&Sym);
Index: ELF/Target.cpp
===================================================================
--- ELF/Target.cpp
+++ ELF/Target.cpp
@@ -17,7 +17,7 @@
 
 #include "Target.h"
 #include "Error.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/ArrayRef.h"
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -9,7 +9,7 @@
 
 #include "Writer.h"
 #include "Config.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
@@ -55,7 +55,7 @@
   void writeHeader();
   void writeSections();
   bool isDiscarded(InputSectionBase<ELFT> *IS) const;
-  StringRef getOutputSectionName(StringRef S) const;
+  StringRef getSegmentName(StringRef S) const;
   bool needsInterpSection() const {
     return !Symtab.getSharedFiles().empty() && !Config->DynamicLinker.empty();
   }
@@ -65,24 +65,24 @@
   uintX_t getEntryAddr() const;
   int getPhdrsNum() const;
 
-  OutputSection<ELFT> *getBSS();
+  Segment<ELFT> *getBSS();
   void addCommonSymbols(std::vector<DefinedCommon<ELFT> *> &Syms);
   void addSharedCopySymbols(std::vector<SharedSymbol<ELFT> *> &Syms);
 
   std::unique_ptr<llvm::FileOutputBuffer> Buffer;
 
-  SpecificBumpPtrAllocator<OutputSection<ELFT>> SecAlloc;
-  SpecificBumpPtrAllocator<MergeOutputSection<ELFT>> MSecAlloc;
-  SpecificBumpPtrAllocator<EHOutputSection<ELFT>> EHSecAlloc;
-  SpecificBumpPtrAllocator<MipsReginfoOutputSection<ELFT>> MReginfoSecAlloc;
+  SpecificBumpPtrAllocator<Segment<ELFT>> SegAlloc;
+  SpecificBumpPtrAllocator<MergeSegment<ELFT>> MSegAlloc;
+  SpecificBumpPtrAllocator<EHSegment<ELFT>> EHSegAlloc;
+  SpecificBumpPtrAllocator<MipsReginfoSegment<ELFT>> MReginfoSegAlloc;
   BumpPtrAllocator Alloc;
-  std::vector<OutputSectionBase<ELFT> *> OutputSections;
-  unsigned getNumSections() const { return OutputSections.size() + 1; }
+  std::vector<SegmentBase<ELFT> *> Segments;
+  unsigned getNumSegments() const { return Segments.size() + 1; }
 
-  void addStartStopSymbols(OutputSectionBase<ELFT> *Sec);
+  void addStartStopSymbols(SegmentBase<ELFT> *Sec);
   void setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags, uintX_t FileOff,
                uintX_t VA, uintX_t Size, uintX_t Align);
-  void copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From);
+  void copyPhdr(Elf_Phdr *PH, SegmentBase<ELFT> *From);
 
   bool HasRelro = false;
   SymbolTable<ELFT> &Symtab;
@@ -91,7 +91,7 @@
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
-  llvm::StringMap<llvm::StringRef> InputToOutputSection;
+  llvm::StringMap<llvm::StringRef> InputToSegment;
 };
 } // anonymous namespace
 
@@ -371,8 +371,8 @@
            .Default(1);
 }
 
-template <class ELFT> static bool isRelroSection(OutputSectionBase<ELFT> *Sec) {
-  typename OutputSectionBase<ELFT>::uintX_t Flags = Sec->getFlags();
+template <class ELFT> static bool isRelroSection(SegmentBase<ELFT> *Sec) {
+  typename SegmentBase<ELFT>::uintX_t Flags = Sec->getFlags();
   if (!(Flags & SHF_ALLOC) || !(Flags & SHF_WRITE))
     return false;
   if (Flags & SHF_TLS)
@@ -392,8 +392,7 @@
 
 // Output section ordering is determined by this function.
 template <class ELFT>
-static bool compareOutputSections(OutputSectionBase<ELFT> *A,
-                                  OutputSectionBase<ELFT> *B) {
+static bool compareSegments(SegmentBase<ELFT> *A, SegmentBase<ELFT> *B) {
   typedef typename ELFFile<ELFT>::uintX_t uintX_t;
 
   uintX_t AFlags = A->getFlags();
@@ -461,11 +460,11 @@
   return false;
 }
 
-template <class ELFT> OutputSection<ELFT> *Writer<ELFT>::getBSS() {
+template <class ELFT> Segment<ELFT> *Writer<ELFT>::getBSS() {
   if (!Out<ELFT>::Bss) {
-    Out<ELFT>::Bss = new (SecAlloc.Allocate())
-        OutputSection<ELFT>(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
-    OutputSections.push_back(Out<ELFT>::Bss);
+    Out<ELFT>::Bss = new (SegAlloc.Allocate())
+        Segment<ELFT>(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
+    Segments.push_back(Out<ELFT>::Bss);
   }
   return Out<ELFT>::Bss;
 }
@@ -527,9 +526,9 @@
 }
 
 template <class ELFT>
-StringRef Writer<ELFT>::getOutputSectionName(StringRef S) const {
-  auto It = InputToOutputSection.find(S);
-  if (It != std::end(InputToOutputSection))
+StringRef Writer<ELFT>::getSegmentName(StringRef S) const {
+  auto It = InputToSegment.find(S);
+  if (It != std::end(InputToSegment))
     return It->second;
 
   if (S.startswith(".text."))
@@ -558,19 +557,18 @@
 bool Writer<ELFT>::isDiscarded(InputSectionBase<ELFT> *IS) const {
   if (!IS || !IS->isLive() || IS == &InputSection<ELFT>::Discarded)
     return true;
-  return InputToOutputSection.lookup(IS->getSectionName()) == "/DISCARD/";
+  return InputToSegment.lookup(IS->getSectionName()) == "/DISCARD/";
 }
 
 template <class ELFT>
-static bool compareSections(OutputSectionBase<ELFT> *A,
-                            OutputSectionBase<ELFT> *B) {
-  auto ItA = Config->OutputSections.find(A->getName());
-  auto ItEnd = std::end(Config->OutputSections);
+static bool compareSections(SegmentBase<ELFT> *A, SegmentBase<ELFT> *B) {
+  auto ItA = Config->Segments.find(A->getName());
+  auto ItEnd = std::end(Config->Segments);
   if (ItA == ItEnd)
-    return compareOutputSections(A, B);
-  auto ItB = Config->OutputSections.find(B->getName());
+    return compareSegments(A, B);
+  auto ItB = Config->Segments.find(B->getName());
   if (ItB == ItEnd)
-    return compareOutputSections(A, B);
+    return compareSegments(A, B);
 
   return std::distance(ItA, ItB) > 0;
 }
@@ -608,15 +606,15 @@
   return true;
 }
 
-// Create output section objects and add them to OutputSections.
+// Create output section objects and add them to Segments.
 template <class ELFT> void Writer<ELFT>::createSections() {
   // .interp needs to be on the first page in the output file.
   if (needsInterpSection())
-    OutputSections.push_back(Out<ELFT>::Interp);
+    Segments.push_back(Out<ELFT>::Interp);
 
-  SmallDenseMap<SectionKey<ELFT::Is64Bits>, OutputSectionBase<ELFT> *> Map;
+  SmallDenseMap<SectionKey<ELFT::Is64Bits>, SegmentBase<ELFT> *> Map;
 
-  std::vector<OutputSectionBase<ELFT> *> RegularSections;
+  std::vector<SegmentBase<ELFT> *> RegularSegments;
 
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
@@ -635,53 +633,52 @@
       if (OutType == SHT_PROGBITS && C->getSectionName() == ".eh_frame" &&
           Config->EMachine == EM_X86_64)
         OutType = SHT_X86_64_UNWIND;
-      SectionKey<ELFT::Is64Bits> Key{getOutputSectionName(C->getSectionName()),
+      SectionKey<ELFT::Is64Bits> Key{getSegmentName(C->getSectionName()),
                                      OutType, OutFlags, EntSize};
-      OutputSectionBase<ELFT> *&Sec = Map[Key];
+      SegmentBase<ELFT> *&Sec = Map[Key];
       if (!Sec) {
         switch (K) {
         case InputSectionBase<ELFT>::Regular:
-          Sec = new (SecAlloc.Allocate())
-              OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+          Sec = new (SegAlloc.Allocate())
+              Segment<ELFT>(Key.Name, Key.Type, Key.Flags);
           break;
         case InputSectionBase<ELFT>::EHFrame:
-          Sec = new (EHSecAlloc.Allocate())
-              EHOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+          Sec = new (EHSegAlloc.Allocate())
+              EHSegment<ELFT>(Key.Name, Key.Type, Key.Flags);
           break;
         case InputSectionBase<ELFT>::Merge:
-          Sec = new (MSecAlloc.Allocate())
-              MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+          Sec = new (MSegAlloc.Allocate())
+              MergeSegment<ELFT>(Key.Name, Key.Type, Key.Flags);
           break;
         case InputSectionBase<ELFT>::MipsReginfo:
-          Sec = new (MReginfoSecAlloc.Allocate())
-              MipsReginfoOutputSection<ELFT>();
+          Sec = new (MReginfoSegAlloc.Allocate()) MipsReginfoSegment<ELFT>();
           break;
         }
-        OutputSections.push_back(Sec);
-        RegularSections.push_back(Sec);
+        Segments.push_back(Sec);
+        RegularSegments.push_back(Sec);
       }
       switch (K) {
       case InputSectionBase<ELFT>::Regular:
-        static_cast<OutputSection<ELFT> *>(Sec)
-            ->addSection(cast<InputSection<ELFT>>(C));
+        static_cast<Segment<ELFT> *>(Sec)->addSection(
+            cast<InputSection<ELFT>>(C));
         break;
       case InputSectionBase<ELFT>::EHFrame:
-        static_cast<EHOutputSection<ELFT> *>(Sec)
-            ->addSection(cast<EHInputSection<ELFT>>(C));
+        static_cast<EHSegment<ELFT> *>(Sec)->addSection(
+            cast<EHInputSection<ELFT>>(C));
         break;
       case InputSectionBase<ELFT>::Merge:
-        static_cast<MergeOutputSection<ELFT> *>(Sec)
-            ->addSection(cast<MergeInputSection<ELFT>>(C));
+        static_cast<MergeSegment<ELFT> *>(Sec)->addSection(
+            cast<MergeInputSection<ELFT>>(C));
         break;
       case InputSectionBase<ELFT>::MipsReginfo:
-        static_cast<MipsReginfoOutputSection<ELFT> *>(Sec)
-            ->addSection(cast<MipsReginfoInputSection<ELFT>>(C));
+        static_cast<MipsReginfoSegment<ELFT> *>(Sec)->addSection(
+            cast<MipsReginfoInputSection<ELFT>>(C));
         break;
       }
     }
   }
 
-  Out<ELFT>::Bss = static_cast<OutputSection<ELFT> *>(
+  Out<ELFT>::Bss = static_cast<Segment<ELFT> *>(
       Map[{".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE, 0}]);
 
   Out<ELFT>::Dynamic->PreInitArraySec = Map.lookup(
@@ -692,7 +689,7 @@
       Map.lookup({".fini_array", SHT_FINI_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
 
   auto AddStartEnd = [&](StringRef Start, StringRef End,
-                         OutputSectionBase<ELFT> *OS) {
+                         SegmentBase<ELFT> *OS) {
     if (OS) {
       Symtab.addSynthetic(Start, *OS, 0);
       Symtab.addSynthetic(End, *OS, OS->getSize());
@@ -709,8 +706,8 @@
   AddStartEnd("__fini_array_start", "__fini_array_end",
               Out<ELFT>::Dynamic->FiniArraySec);
 
-  for (OutputSectionBase<ELFT> *Sec : RegularSections)
-    addStartStopSymbols(Sec);
+  for (SegmentBase<ELFT> *Seg : RegularSegments)
+    addStartStopSymbols(Seg);
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
@@ -780,37 +777,37 @@
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   if (Out<ELFT>::SymTab)
-    OutputSections.push_back(Out<ELFT>::SymTab);
-  OutputSections.push_back(Out<ELFT>::ShStrTab);
+    Segments.push_back(Out<ELFT>::SymTab);
+  Segments.push_back(Out<ELFT>::ShStrTab);
   if (Out<ELFT>::StrTab)
-    OutputSections.push_back(Out<ELFT>::StrTab);
+    Segments.push_back(Out<ELFT>::StrTab);
   if (isOutputDynamic()) {
-    OutputSections.push_back(Out<ELFT>::DynSymTab);
+    Segments.push_back(Out<ELFT>::DynSymTab);
     if (Out<ELFT>::GnuHashTab)
-      OutputSections.push_back(Out<ELFT>::GnuHashTab);
+      Segments.push_back(Out<ELFT>::GnuHashTab);
     if (Out<ELFT>::HashTab)
-      OutputSections.push_back(Out<ELFT>::HashTab);
-    OutputSections.push_back(Out<ELFT>::Dynamic);
-    OutputSections.push_back(Out<ELFT>::DynStrTab);
+      Segments.push_back(Out<ELFT>::HashTab);
+    Segments.push_back(Out<ELFT>::Dynamic);
+    Segments.push_back(Out<ELFT>::DynStrTab);
     if (Out<ELFT>::RelaDyn->hasRelocs())
-      OutputSections.push_back(Out<ELFT>::RelaDyn);
+      Segments.push_back(Out<ELFT>::RelaDyn);
     // This is a MIPS specific section to hold a space within the data segment
     // of executable file which is pointed to by the DT_MIPS_RLD_MAP entry.
     // See "Dynamic section" in Chapter 5 in the following document:
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     if (Config->EMachine == EM_MIPS && !Config->Shared) {
-      Out<ELFT>::MipsRldMap = new (SecAlloc.Allocate())
-          OutputSection<ELFT>(".rld_map", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
+      Out<ELFT>::MipsRldMap = new (SegAlloc.Allocate())
+          Segment<ELFT>(".rld_map", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
       Out<ELFT>::MipsRldMap->setSize(ELFT::Is64Bits ? 8 : 4);
       Out<ELFT>::MipsRldMap->updateAlign(ELFT::Is64Bits ? 8 : 4);
-      OutputSections.push_back(Out<ELFT>::MipsRldMap);
+      Segments.push_back(Out<ELFT>::MipsRldMap);
     }
   }
 
   // We always need to add rel[a].plt to output if it has entries.
   // Even during static linking it can contain R_[*]_IRELATIVE relocations.
   if (Out<ELFT>::RelaPlt && Out<ELFT>::RelaPlt->hasRelocs()) {
-    OutputSections.push_back(Out<ELFT>::RelaPlt);
+    Segments.push_back(Out<ELFT>::RelaPlt);
     Out<ELFT>::RelaPlt->Static = !isOutputDynamic();
   }
 
@@ -825,21 +822,20 @@
     needsGot = true;
 
   if (needsGot)
-    OutputSections.push_back(Out<ELFT>::Got);
+    Segments.push_back(Out<ELFT>::Got);
   if (Out<ELFT>::GotPlt && !Out<ELFT>::GotPlt->empty())
-    OutputSections.push_back(Out<ELFT>::GotPlt);
+    Segments.push_back(Out<ELFT>::GotPlt);
   if (!Out<ELFT>::Plt->empty())
-    OutputSections.push_back(Out<ELFT>::Plt);
+    Segments.push_back(Out<ELFT>::Plt);
 
-  std::stable_sort(OutputSections.begin(), OutputSections.end(),
-                   compareSections<ELFT>);
+  std::stable_sort(Segments.begin(), Segments.end(), compareSections<ELFT>);
 
-  for (unsigned I = 0, N = OutputSections.size(); I < N; ++I) {
-    OutputSections[I]->SectionIndex = I + 1;
-    HasRelro |= (Config->ZRelro && isRelroSection(OutputSections[I]));
+  for (unsigned I = 0, N = Segments.size(); I < N; ++I) {
+    Segments[I]->SectionIndex = I + 1;
+    HasRelro |= (Config->ZRelro && isRelroSection(Segments[I]));
   }
 
-  for (OutputSectionBase<ELFT> *Sec : OutputSections)
+  for (SegmentBase<ELFT> *Sec : Segments)
     Out<ELFT>::ShStrTab->add(Sec->getName());
 
   // Finalizers fix each section's size.
@@ -851,7 +847,7 @@
     Out<ELFT>::DynSymTab->finalize();
 
   // Fill other section headers.
-  for (OutputSectionBase<ELFT> *Sec : OutputSections)
+  for (SegmentBase<ELFT> *Sec : Segments)
     Sec->finalize();
 
   // If we have a .opd section (used under PPC64 for function descriptors),
@@ -879,7 +875,7 @@
 // respectively. This is not requested by the ELF standard, but GNU ld and
 // gold provide the feature, and used by many programs.
 template <class ELFT>
-void Writer<ELFT>::addStartStopSymbols(OutputSectionBase<ELFT> *Sec) {
+void Writer<ELFT>::addStartStopSymbols(SegmentBase<ELFT> *Sec) {
   StringRef S = Sec->getName();
   if (!isValidCIdentifier(S))
     return;
@@ -892,7 +888,7 @@
     Symtab.addSynthetic(Stop, *Sec, Sec->getSize());
 }
 
-template <class ELFT> static bool needsPhdr(OutputSectionBase<ELFT> *Sec) {
+template <class ELFT> static bool needsPhdr(SegmentBase<ELFT> *Sec) {
   return Sec->getFlags() & SHF_ALLOC;
 }
 
@@ -946,7 +942,7 @@
   bool RelroAligned = false;
   uintX_t ThreadBSSOffset = 0;
   // Create phdrs as we assign VAs and file offsets to all output sections.
-  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+  for (SegmentBase<ELFT> *Sec : Segments) {
     Elf_Phdr *PH = &Phdrs[PhdrIdx];
     if (needsPhdr<ELFT>(Sec)) {
       uintX_t Flags = toPhdrFlags(Sec->getFlags());
@@ -1035,7 +1031,7 @@
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
-  FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
+  FileSize = SectionHeaderOff + getNumSegments() * sizeof(Elf_Shdr);
 
   // Update "_end" and "end" symbols so that they
   // point to the end of the data segment.
@@ -1066,7 +1062,7 @@
   if (!Config->ZExecStack)
     ++I;
   uintX_t Last = PF_R;
-  for (OutputSectionBase<ELFT> *Sec : OutputSections) {
+  for (SegmentBase<ELFT> *Sec : Segments) {
     if (!needsPhdr<ELFT>(Sec))
       continue;
     if (Sec->getFlags() & SHF_TLS)
@@ -1121,7 +1117,7 @@
   EHdr->e_phentsize = sizeof(Elf_Phdr);
   EHdr->e_phnum = Phdrs.size();
   EHdr->e_shentsize = sizeof(Elf_Shdr);
-  EHdr->e_shnum = getNumSections();
+  EHdr->e_shnum = getNumSegments();
   EHdr->e_shstrndx = Out<ELFT>::ShStrTab->SectionIndex;
 
   // Write the program header table.
@@ -1129,7 +1125,7 @@
 
   // Write the section header table. Note that the first table entry is null.
   auto SHdrs = reinterpret_cast<Elf_Shdr *>(Buf + EHdr->e_shoff);
-  for (OutputSectionBase<ELFT> *Sec : OutputSections)
+  for (SegmentBase<ELFT> *Sec : Segments)
     Sec->writeHeaderTo(++SHdrs);
 }
 
@@ -1146,12 +1142,12 @@
 
   // PPC64 needs to process relocations in the .opd section before processing
   // relocations in code-containing sections.
-  if (OutputSectionBase<ELFT> *Sec = Out<ELFT>::Opd) {
+  if (SegmentBase<ELFT> *Sec = Out<ELFT>::Opd) {
     Out<ELFT>::OpdBuf = Buf + Sec->getFileOff();
     Sec->writeTo(Buf + Sec->getFileOff());
   }
 
-  for (OutputSectionBase<ELFT> *Sec : OutputSections)
+  for (SegmentBase<ELFT> *Sec : Segments)
     if (Sec != Out<ELFT>::Opd)
       Sec->writeTo(Buf + Sec->getFileOff());
 }
@@ -1183,7 +1179,7 @@
 }
 
 template <class ELFT>
-void Writer<ELFT>::copyPhdr(Elf_Phdr *PH, OutputSectionBase<ELFT> *From) {
+void Writer<ELFT>::copyPhdr(Elf_Phdr *PH, SegmentBase<ELFT> *From) {
   PH->p_flags = toPhdrFlags(From->getFlags());
   PH->p_offset = From->getFileOff();
   PH->p_vaddr = From->getVA();
@@ -1194,10 +1190,10 @@
 }
 
 template <class ELFT> void Writer<ELFT>::buildSectionMap() {
-  for (const std::pair<StringRef, std::vector<StringRef>> &OutSec :
-       Config->OutputSections)
-    for (StringRef Name : OutSec.second)
-      InputToOutputSection[Name] = OutSec.first;
+  for (const std::pair<StringRef, std::vector<StringRef>> &Segm :
+       Config->Segments)
+    for (StringRef Name : Segm.second)
+      InputToSegment[Name] = Segm.first;
 }
 
 template void lld::elf2::writeResult<ELF32LE>(SymbolTable<ELF32LE> *Symtab);