Rename OutputSection -> Segment.

[ruiu]

Summary

Segment is the official terminology in the ELF spec to denote
the output section. Segment is better than OutputSection since
it is shorter and less confusing than InputSection.

[• rafael]

Unfortunately I don't think that is correct. The spec says

---

In the first phase, input sections that match in name, type and
attribute flags should be concatenated into single sections ...

In the second phase, sections should be assigned to segments or other

units based on their attribute flags ...

So our OutputSection is what the "single sections" refers to.

[emaste]

Segment is the official terminology in the ELF spec to denote the output section.

This is confusing to me - the output ELF file has both sections and segments.

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_llvm_library(lldELF2
   Driver.cpp
   DriverUtils.cpp
   Error.cpp
   InputFiles.cpp
   InputSection.cpp
   LinkerScript.cpp
   MarkLive.cpp
-  OutputSections.cpp
+  Segments.cpp
   SymbolTable.cpp
   Symbols.cpp
   Target.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   Object
   Option
   MC
   Support
   )
 
 add_dependencies(lldELF2 ELFOptionsTableGen)

ELF/Config.h

struct Configuration {
   llvm::StringRef Entry;
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   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;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;

ELF/InputSection.h

 #include "Config.h"
 #include "lld/Core/LLVM.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 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 {
 protected:
   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>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   const Elf_Shdr *Header;
 
   // The file this section is from.
   ObjectFile<ELFT> *File;
 
 public:
   enum Kind { Regular, EHFrame, Merge, MipsReginfo };
   Kind SectionKind;
 
   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.
   bool isLive() const { return !Config->GcSections || Live; }
   bool Live = false;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const { return Header->sh_size; }
public:
   // beginning of the output section.
   void writeTo(uint8_t *Buf);
 
   // Relocation sections that refer to this one.
   SmallVector<const Elf_Shdr *, 1> RelocSections;
 
   // 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);
 };
 
 // MIPS .reginfo section provides information on the registers used by the code
 // in the object file. Linker should collect this information and write a single
 // .reginfo section in the output file. The output section contains a union of
 // used registers masks taken from input .reginfo sections and final value

ELF/InputSection.cpp

 //===- InputSection.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputSection.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Target.h"
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
ArrayRef<uint8_t> InputSectionBase<ELFT>::getSectionData() const {
   return *Ret;
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t
 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:
     return cast<MergeInputSection<ELFT>>(this)->getOffset(Offset);
   case MipsReginfo:
     return cast<MipsReginfoInputSection<ELFT>>(this)->getOffset(Offset);
   }
   llvm_unreachable("Invalid section kind");
for (size_t I = 0; I < Num; ++I) {
     const RelType &RI = *(Rels.begin() + I);
     uint32_t SymIndex = RI.getSymbol(Config->Mips64EL);
     uint32_t Type = RI.getType(Config->Mips64EL);
     uintX_t Offset = getOffset(RI.r_offset);
     if (Offset == (uintX_t)-1)
       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) &&
         !Target->isTlsOptimized(Type, nullptr)) {
       Target->relocateOne(BufLoc, BufEnd, Type, AddrLoc,
                           Out<ELFT>::Got->getLocalTlsIndexVA() +
                               getAddend<ELFT>(RI));
       continue;
void InputSectionBase<ELFT>::relocate(uint8_t *Buf, uint8_t *BufEnd,
   }
 }
 
 template <class ELFT> void InputSection<ELFT>::writeTo(uint8_t *Buf) {
   if (this->Header->sh_type == SHT_NOBITS)
     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)
       this->relocate(Buf, BufEnd, EObj.relas(RelSec));
     else
       this->relocate(Buf, BufEnd, EObj.rels(RelSec));
   }
 }
MergeInputSection<ELFT>::getOffset(uintX_t Offset) {
   uintX_t &Base = I->second;
   if (Base != uintX_t(-1))
     return Base + Addend;
 
   // Map the base to the offset in the output section and cache it.
   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;
 }
 
 template <class ELFT>
 MipsReginfoInputSection<ELFT>::MipsReginfoInputSection(ObjectFile<ELFT> *F,
                                                        const Elf_Shdr *Header)
     : InputSectionBase<ELFT>(F, Header, InputSectionBase<ELFT>::MipsReginfo) {}
 

ELF/LinkerScript.cpp

private:
   void readGroup();
   void readInclude();
   void readOutput();
   void readOutputArch();
   void readOutputFormat();
   void readSearchDir();
   void readSections();
 
-  void readOutputSectionDescription();
+  void readSegmentDescription();
 
   StringSaver Saver;
   std::vector<StringRef> Tokens;
   size_t Pos = 0;
   bool IsUnderSysroot;
 };
 }
 
void LinkerScript::readSearchDir() {
   expect("(");
   Config->SearchPaths.push_back(next());
   expect(")");
 }
 
 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("{");
   while (!skip("}")) {
     next(); // Skip input file name.
     expect("(");
     while (!skip(")"))
       InputSections.push_back(next());

ELF/MarkLive.cpp

 // by default. Starting with GC-root symbols or sections, markLive function
 // defined in this file visits all reachable sections to set their Live
 // bits. Writer will then ignore sections whose Live bits are off, so that
 // such sections are removed from output.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputSection.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/ELF.h"
 #include <functional>
 #include <vector>
 

ELF/Segments.h

-//===- OutputSections.h -----------------------------------------*- C++ -*-===//
+//===- Segments.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 

 template <class ELFT> class SymbolTable;
 template <class ELFT> class SymbolTableSection;
 template <class ELFT> class StringTableSection;
 template <class ELFT> class EHInputSection;
 template <class ELFT> class InputSection;
 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;
 
 // Flag to force GOT to be in output if we have relocations
 // that relies on its address.
 extern bool HasGotOffRel;
 
 template <class ELFT>

 template <class ELFT>
 bool shouldKeepInSymtab(
     const ObjectFile<ELFT> &File, StringRef Name,
     const typename llvm::object::ELFFile<ELFT>::Elf_Sym &Sym);
 
 // 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; }
   void writeHeaderTo(Elf_Shdr *SHdr);
   StringRef getName() { return Name; }
 
   unsigned SectionIndex;
 
public:
   }
 
   virtual void finalize() {}
   virtual void writeTo(uint8_t *Buf) = 0;
 
 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:
   GotSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool addDynTlsEntry(SymbolBody *Sym);
public:
 
   uint32_t getLocalTlsIndexVA() { return Base::getVA() + LocalTlsIndexOff; }
 
 private:
   std::vector<const SymbolBody *> Entries;
   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:
   GotPltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const;
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   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:
   PltSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   void addEntry(SymbolBody *Sym);
   bool empty() const { return Entries.empty(); }
   uintX_t getEntryAddr(const SymbolBody &B) const;
 
 private:
   std::vector<std::pair<const SymbolBody *, unsigned>> Entries;
 };
 
 template <class ELFT> struct DynamicReloc {
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Rel Elf_Rel;
   InputSectionBase<ELFT> *C;
   const Elf_Rel *RI;
 };
 
 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;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   SymbolTableSection(SymbolTable<ELFT> &Table,
                      StringTableSection<ELFT> &StrTabSec);
 
private:
 
   SymbolTable<ELFT> &Table;
   StringTableSection<ELFT> &StrTabSec;
   std::vector<SymbolBody *> Symbols;
   unsigned NumVisible = 0;
   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;
 
 public:
   RelocationSection(StringRef Name, bool IsRela);
   void addReloc(const DynamicReloc<ELFT> &Reloc) { Relocs.push_back(Reloc); }
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   bool hasRelocs() const { return !Relocs.empty(); }
   bool isRela() const { return IsRela; }
 
   bool Static = false;
 
 private:
   bool applyTlsDynamicReloc(SymbolBody *Body, uint32_t Type, Elf_Rel *P,
                             Elf_Rel *N);
 
   std::vector<DynamicReloc<ELFT>> Relocs;
   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;
 
 private:
   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);
   void finalize() override;
 
 private:
   llvm::StringTableBuilder Builder{llvm::StringTableBuilder::RAW};
 };
 
 // FDE or CIE
 template <class ELFT> struct EHRegion {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   EHRegion(EHInputSection<ELFT> *S, unsigned Index);
   StringRef data() const;
   EHInputSection<ELFT> *S;
   unsigned Index;
 };
 
 template <class ELFT> struct Cie : public EHRegion<ELFT> {
   Cie(EHInputSection<ELFT> *S, unsigned Index);
   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>
   void addSectionAux(
       EHInputSection<ELFT> *S,
       llvm::iterator_range<const llvm::object::Elf_Rel_Impl<ELFT, IsRela> *>
           Rels);
 
   void addSection(EHInputSection<ELFT> *S);
 
 private:
   uintX_t readEntryLength(ArrayRef<uint8_t> D);
 
   std::vector<EHInputSection<ELFT> *> Sections;
   std::vector<Cie<ELFT>> Cies;
 
   // Maps CIE content + personality to a index in Cies.
   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);
   void add(StringRef S) { StrTabBuilder.add(S); }
   size_t getOffset(StringRef S) const { return StrTabBuilder.getOffset(S); }
   StringRef data() const { return StrTabBuilder.data(); }
   void writeTo(uint8_t *Buf) override;
 
   void finalize() override {
     StrTabBuilder.finalize();
     this->Header.sh_size = StrTabBuilder.data().size();
   }
 
   bool isDynamic() const { return Dynamic; }
 
 private:
   const bool Dynamic;
   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:
   HashTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
 };
 
 // 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;
 
 public:
   GnuHashTableSection();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
private:
 
   std::vector<HashedSymbolData> HashedSymbols;
 
   unsigned MaskWords;
   unsigned NBuckets;
   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;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Shdr Elf_Shdr;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Sym Elf_Sym;
 
 public:
   DynamicSection(SymbolTable<ELFT> &SymTab);
   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;
   const SymbolBody *InitSym = nullptr;
   const SymbolBody *FiniSym = nullptr;
   uint32_t DtFlags = 0;
   uint32_t DtFlags1 = 0;
 };
 
 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);
 
 private:
   uint32_t GeneralMask = 0;
 };
 
 // All output sections that are hadnled by the linker specially are
 // globally accessible. Writer initializes them, so don't use them
 // until Writer is initialized.
 template <class ELFT> struct Out {
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;
   typedef typename llvm::object::ELFFile<ELFT>::Elf_Phdr Elf_Phdr;
   static DynamicSection<ELFT> *Dynamic;
   static GnuHashTableSection<ELFT> *GnuHashTab;
   static GotPltSection<ELFT> *GotPlt;
   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;
   static RelocationSection<ELFT> *RelaPlt;
   static StringTableSection<ELFT> *DynStrTab;
   static StringTableSection<ELFT> *ShStrTab;
   static StringTableSection<ELFT> *StrTab;
   static SymbolTableSection<ELFT> *DynSymTab;
   static SymbolTableSection<ELFT> *SymTab;
   static Elf_Phdr *TlsPhdr;
 };
 
 template <class ELFT> DynamicSection<ELFT> *Out<ELFT>::Dynamic;
 template <class ELFT> GnuHashTableSection<ELFT> *Out<ELFT>::GnuHashTab;
 template <class ELFT> GotPltSection<ELFT> *Out<ELFT>::GotPlt;
 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;
 template <class ELFT> RelocationSection<ELFT> *Out<ELFT>::RelaPlt;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::DynStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::ShStrTab;
 template <class ELFT> StringTableSection<ELFT> *Out<ELFT>::StrTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::DynSymTab;
 template <class ELFT> SymbolTableSection<ELFT> *Out<ELFT>::SymTab;
 template <class ELFT> typename Out<ELFT>::Elf_Phdr *Out<ELFT>::TlsPhdr;
 
 } // namespace elf2
 } // namespace lld
 
 #endif // LLD_ELF_OUTPUT_SECTIONS_H

ELF/Segments.cpp

-//===- OutputSections.cpp -------------------------------------------------===//
+//===- Segments.cpp -------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Config.h"
 #include "SymbolTable.h"
 #include "Target.h"
 #include "llvm/Support/MathExtras.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::support::endian;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 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,
     : Name(Name) {
   memset(&Header, 0, sizeof(Elf_Shdr));
   Header.sh_type = sh_type;
   Header.sh_flags = sh_flags;
 }
 
 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,
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotPltIndex = Target->getGotPltHeaderEntriesNum() + Entries.size();
   Entries.push_back(Sym);
 }
 
template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const SymbolBody *B : Entries) {
     Target->writeGotPltEntry(Buf, Out<ELFT>::Plt->getEntryAddr(*B));
     Buf += sizeof(uintX_t);
   }
 }
 
 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,
   if (Config->EMachine == EM_MIPS)
     this->Header.sh_flags |= llvm::ELF::SHF_MIPS_GPREL;
   this->Header.sh_addralign = sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::addEntry(SymbolBody *Sym) {
   Sym->GotIndex = Target->getGotHeaderEntriesNum() + Entries.size();
   Entries.push_back(Sym);
if (Config->EMachine != EM_MIPS && canBePreempted(B, false))
       continue; // The dynamic linker will take care of it.
     uintX_t VA = getSymVA<ELFT>(*B);
     write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Entry, VA);
   }
 }
 
 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,
   this->Header.sh_addralign = 16;
 }
 
 template <class ELFT> void PltSection<ELFT>::writeTo(uint8_t *Buf) {
   size_t Off = 0;
   bool LazyReloc = Target->supportsLazyRelocations();
   if (LazyReloc) {
     // First write PLT[0] entry which is special.

 
 template <class ELFT> void PltSection<ELFT>::finalize() {
   this->Header.sh_size = Target->getPltZeroEntrySize() +
                          Entries.size() * Target->getPltEntrySize();
 }
 
 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,
       IsRela(IsRela) {
   this->Header.sh_entsize = IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel);
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 // Applies corresponding symbol and type for dynamic tls relocation.
 // Returns true if relocation was handled.
 template <class ELFT>
 bool RelocationSection<ELFT>::applyTlsDynamicReloc(SymbolBody *Body,
                                                    uint32_t Type, Elf_Rel *P,
                                                    Elf_Rel *N) {
   if (Target->isTlsLocalDynamicReloc(Type)) {
     P->setSymbolAndType(0, Target->getTlsModuleIndexReloc(), Config->Mips64EL);
     P->r_offset = Out<ELFT>::Got->getLocalTlsIndexVA();
     return true;
   }
 
   if (!Body || !Target->isTlsGlobalDynamicReloc(Type))
     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;
   }
 
   P->setSymbolAndType(Body->DynamicSymbolTableIndex,
                       Target->getTlsModuleIndexReloc(), Config->Mips64EL);
   P->r_offset = Out<ELFT>::Got->getGlobalDynAddr(*Body);
   N->setSymbolAndType(Body->DynamicSymbolTableIndex,
if (NeedsGot) {
       if (LazyReloc)
         P->r_offset = Out<ELFT>::GotPlt->getEntryAddr(*Body);
       else
         P->r_offset = Out<ELFT>::Got->getEntryAddr(*Body);
     } else if (NeedsCopy) {
       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;
     if (IsRela && !NeedsGot)
       OrigAddend = static_cast<const Elf_Rela &>(RI).r_addend;
 
     uintX_t Addend;
     if (NeedsCopy)

 template <class ELFT> void RelocationSection<ELFT>::finalize() {
   this->Header.sh_link = Static ? Out<ELFT>::SymTab->SectionIndex
                                 : Out<ELFT>::DynSymTab->SectionIndex;
   this->Header.sh_size = Relocs.size() * this->Header.sh_entsize;
 }
 
 template <class ELFT>
 InterpSection<ELFT>::InterpSection()
-    : OutputSectionBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
-                              llvm::ELF::SHF_ALLOC) {
+    : SegmentBase<ELFT>(".interp", llvm::ELF::SHT_PROGBITS,
   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;
 }
 
 template <class ELFT> void InterpSection<ELFT>::writeTo(uint8_t *Buf) {
   memcpy(Buf, Config->DynamicLinker.data(), Config->DynamicLinker.size());
 }
 
 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);
 }
 
 static uint32_t hashSysv(StringRef Name) {
   uint32_t H = 0;
   for (char C : Name) {
     H = (H << 4) + C;
     uint32_t G = H & 0xf0000000;
     if (G)
       H ^= G >> 24;
     H &= ~G;
   }
   return H;
 }
 
 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.
   // FIXME: This is simplistic. We can try to optimize it, but implementing
   // support for SHT_GNU_HASH is probably even more profitable.
   NumEntries += Out<ELFT>::DynSymTab->getNumSymbols();
   this->Header.sh_size = NumEntries * sizeof(Elf_Word);
 }
static uint32_t hashGnu(StringRef Name) {
   uint32_t H = 5381;
   for (uint8_t C : Name)
     H = (H << 5) + H + C;
   return H;
 }
 
 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,
   this->Header.sh_entsize = ELFT::Is64Bits ? 0 : 4;
   this->Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 template <class ELFT>
 unsigned GnuHashTableSection<ELFT>::calcNBuckets(unsigned NumHashed) {
   if (!NumHashed)
     return 0;
void GnuHashTableSection<ELFT>::addSymbols(std::vector<SymbolBody *> &Symbols) {
 
   Symbols = std::move(NotHashed);
   for (const HashedSymbolData &Item : HashedSymbols)
     Symbols.push_back(Item.Body);
 }
 
 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,
       SymTab(SymTab) {
   Elf_Shdr &Header = this->Header;
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
   Header.sh_entsize = ELFT::Is64Bits ? 16 : 8;
 
   // .dynamic section is not writable on MIPS.
   // See "Special Section" in Chapter 4 in the following document:
   // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   //   DT_RPATH is used for indirect dependencies as well.
   if (!Config->RPath.empty())
     WriteVal(Config->EnableNewDtags ? DT_RUNPATH : DT_RPATH,
              Out<ELFT>::DynStrTab->getOffset(Config->RPath));
 
   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());
     WriteVal(T2, Sec->getSize());
   };
   WriteArray(DT_PREINIT_ARRAY, DT_PREINIT_ARRAYSZ, PreInitArraySec);
   WriteArray(DT_INIT_ARRAY, DT_INIT_ARRAYSZ, InitArraySec);
   WriteArray(DT_FINI_ARRAY, DT_FINI_ARRAYSZ, FiniArraySec);
if (Config->EMachine == EM_MIPS) {
     if (Out<ELFT>::MipsRldMap)
       WritePtr(DT_MIPS_RLD_MAP, Out<ELFT>::MipsRldMap->getVA());
   }
 
   WriteVal(DT_NULL, 0);
 }
 
 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;
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t lld::elf2::getSymVA(const SymbolBody &S) {
   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;
   case SymbolBody::DefinedRegularKind: {
     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;
   case SymbolBody::SharedKind: {
     auto &SS = cast<SharedSymbol<ELFT>>(S);
     if (SS.NeedsCopy)
       return Out<ELFT>::Bss->getVA() + SS.OffsetInBSS;
     return 0;
const Elf_Sym *Sym =
       File.getObj().getRelocationSymbol(&RI, File.getSymbolTable());
 
   if (!Sym)
     error("Unsupported relocation without symbol");
 
   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
   // the group are not allowed. Unfortunately .eh_frame breaks that rule
   // and must be treated specially. For now we just replace the symbol with
   // 0.
   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;
 
   uintX_t Offset = Sym->st_value;
   if (Sym->getType() == STT_SECTION) {
     Offset += Addend;
     Addend = 0;
   }
   return VA + cast<MergeInputSection<ELFT>>(Section)->getOffset(Offset) +
          Addend;
 }
 
 // Returns true if a symbol can be replaced at load-time by a symbol
 // 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;
 
   if (Body->isUndefined()) {
     if (!Body->isWeak())
       return true;
 
     // This is an horrible corner case. Ideally we would like to say that any
if (Body->isUndefined()) {
     // user knows what he or she is doing and can handle a dynamic relocation.
     return Config->Shared || NeedsGot;
   }
   if (!Config->Shared)
     return false;
   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)
     : S(S), Index(Index) {}
 
 template <class ELFT> StringRef EHRegion<ELFT>::data() const {
   ArrayRef<uint8_t> SecData = S->getSectionData();
   ArrayRef<std::pair<uintX_t, uintX_t>> Offsets = S->Offsets;
   size_t Start = Offsets[Index].first;
   size_t End =
       Index == Offsets.size() - 1 ? SecData.size() : Offsets[Index + 1].first;
   return StringRef((const char *)SecData.data() + Start, End - Start);
 }
 
 template <class ELFT>
 Cie<ELFT>::Cie(EHInputSection<ELFT> *S, unsigned Index)
     : EHRegion<ELFT>(S, Index) {}
 
 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;
 
   Sections.push_back(S);
 
   ArrayRef<uint8_t> SecData = S->getSectionData();
   ArrayRef<uint8_t> D = SecData;
while (!D.empty()) {
     }
 
     Offset = NextOffset;
     D = D.slice(Length);
   }
 }
 
 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)
     error("Truncated CIE/FDE length");
   uint64_t Len = read32<E>(D.data());
   if (Len < UINT32_MAX) {
     if (Len > (UINT32_MAX - 4))
       error("CIE/FIE size is too large");
     if (Len + 4 > D.size())
       error("CIE/FIE ends past the end of the section");
     return Len + 4;
   }
 
   if (D.size() < 12)
     error("Truncated CIE/FDE length");
   Len = read64<E>(D.data() + 4);
   if (Len > (UINT64_MAX - 12))
     error("CIE/FIE size is too large");
   if (Len + 12 > D.size())
     error("CIE/FIE ends past the end of the section");
   return Len + 12;
 }
 
 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(
         S, make_range((const Elf_Rela *)nullptr, (const Elf_Rela *)nullptr));
   ELFFile<ELFT> &Obj = S->getFile()->getObj();
   if (RelSec->sh_type == SHT_RELA)
     return addSectionAux(S, Obj.relas(RelSec));
   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) {
     size_t CieOffset = Offset;
 
     StringRef CieData = C.data();
     memcpy(Buf + Offset, CieData.data(), CieData.size());
     C.S->Offsets[C.Index].second = Offset;
for (EHInputSection<ELFT> *S : Sections) {
     if (RelSec->sh_type == SHT_RELA)
       S->relocate(Buf, nullptr, EObj.relas(RelSec));
     else
       S->relocate(Buf, nullptr, EObj.rels(RelSec));
   }
 }
 
 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,
+    : 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());
     return;
   }
   for (const std::pair<StringRef, size_t> &P : Builder.getMap()) {
     StringRef Data = P.first;
     memcpy(Buf + P.second, Data.data(), Data.size());
for (unsigned I = 0, N = S.size(); I != N; I += EntSize) {
     const char *B = S.begin() + I;
     if (std::all_of(B, B + EntSize, [](char C) { return C == 0; }))
       return I;
   }
   return StringRef::npos;
 }
 
 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;
 
   ArrayRef<uint8_t> D = S->getSectionData();
   StringRef Data((const char *)D.data(), D.size());
   uintX_t EntSize = S->getSectionHdr()->sh_entsize;
   uintX_t Offset = 0;
for (unsigned I = 0, N = Data.size(); I != N; I += EntSize) {
       StringRef Entry = Data.substr(I, EntSize);
       size_t OutputOffset = Builder.add(Entry);
       S->Offsets.push_back(std::make_pair(Offset, OutputOffset));
       Offset += EntSize;
     }
   }
 }
 
-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();
 }
 
 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(Dynamic) {
   this->Header.sh_addralign = 1;
 }
 
 template <class ELFT> void StringTableSection<ELFT>::writeTo(uint8_t *Buf) {
   StringRef Data = StrTabBuilder.data();
   memcpy(Buf, Data.data(), Data.size());
 }
if (Config->DiscardLocals)
     return false;
 
   return !(Sec->getSectionHdr()->sh_flags & SHF_MERGE);
 }
 
 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);
   Header.sh_addralign = ELFT::Is64Bits ? 8 : 4;
 }
 
 // Orders symbols according to their positions in the GOT,
 // in compliance with MIPS ABI rules.
for (const Elf_Sym &Sym : Syms) {
       uintX_t VA = 0;
       if (Sym.st_shndx == SHN_ABS) {
         ESym->st_shndx = SHN_ABS;
         VA = Sym.st_value;
       } else {
         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;
       ESym->setBindingAndType(Sym.getBinding(), Sym.getType());
       ESym->st_value = VA;
       Buf += sizeof(*ESym);
     }
   }

 }
 
 template <class ELFT>
 void SymbolTableSection<ELFT>::writeGlobalSymbols(uint8_t *Buf) {
   // Write the internal symbol table contents to the output symbol table
   // 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:
     case SymbolBody::UndefinedKind:
     case SymbolBody::DefinedAbsoluteKind:
     case SymbolBody::LazyKind:
       break;
     }
for (SymbolBody *Body : Symbols) {
 
     ESym->setBindingAndType(getSymbolBinding(Body), Type);
     ESym->st_size = Size;
     ESym->setVisibility(Body->getVisibility());
     ESym->st_value = getSymVA<ELFT>(*Body);
 
     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;
   }
 }
 
 template <class ELFT>
 uint8_t SymbolTableSection<ELFT>::getSymbolBinding(SymbolBody *Body) {
   uint8_t Visibility = Body->getVisibility();
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;
   if (const Elf_Sym *ESym = getElfSym<ELFT>(*Body))
     return ESym->getBinding();
   if (isa<DefinedSynthetic<ELFT>>(Body))
     return STB_LOCAL;
   return Body->isWeak() ? STB_WEAK : STB_GLOBAL;
 }
 
 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>;
 template class GotPltSection<ELF64LE>;
 template class GotPltSection<ELF64BE>;
 
 template class GotSection<ELF32LE>;
 template class GotSection<ELF32BE>;

 template class HashTableSection<ELF64LE>;
 template class HashTableSection<ELF64BE>;
 
 template class DynamicSection<ELF32LE>;
 template class DynamicSection<ELF32BE>;
 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>;
 template class StringTableSection<ELF64LE>;
 template class StringTableSection<ELF64BE>;
 
 template class SymbolTableSection<ELF32LE>;
 template class SymbolTableSection<ELF32BE>;

ELF/SymbolTable.h

 #define LLD_ELF_SYMBOL_TABLE_H
 
 #include "InputFiles.h"
 #include "llvm/ADT/MapVector.h"
 
 namespace lld {
 namespace elf2 {
 class Lazy;
-template <class ELFT> class OutputSectionBase;
+template <class ELFT> class SegmentBase;
 struct Symbol;
 class Undefined;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
 // files whose archive members are not yet loaded).
 //
 // We put all symbols of all files to a SymbolTable, and the
public:
   const std::vector<std::unique_ptr<SharedFile<ELFT>>> &getSharedFiles() const {
     return SharedFiles;
   }
 
   SymbolBody *addUndefined(StringRef Name);
   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);
   void scanShlibUndefined();
   SymbolBody *find(StringRef Name);
 
 private:
   Symbol *insert(SymbolBody *New);

ELF/SymbolTable.cpp

 
 template <class ELFT>
 void SymbolTable<ELFT>::addAbsolute(StringRef Name,
                                     typename ELFFile<ELFT>::Elf_Sym &ESym) {
   resolve(new (Alloc) DefinedAbsolute<ELFT>(Name, ESym));
 }
 
 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);
 }
 
 template <class ELFT>
 SymbolBody *SymbolTable<ELFT>::addIgnored(StringRef Name) {
   auto *Sym = new (Alloc)
       DefinedAbsolute<ELFT>(Name, DefinedAbsolute<ELFT>::IgnoreUndef);
   resolve(Sym);

ELF/Symbols.h

 
 namespace lld {
 namespace elf2 {
 
 class ArchiveFile;
 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.
 // Called at the beginning of main().
 void initSymbols();
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.

 // DefinedSynthetic is a class to represent linker-generated ELF symbols.
 // The difference from the regular symbol is that DefinedSynthetic symbols
 // don't belong to any input files or sections. Thus, its constructor
 // takes an output section to calculate output VA, etc.
 template <class ELFT> class DefinedSynthetic : public Defined {
 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.
 class Undefined : public SymbolBody {
   typedef SymbolBody::Kind Kind;
   bool CanKeepUndefined;
 
 protected:

ELF/Symbols.cpp

 UndefinedElf<ELFT>::UndefinedElf(StringRef N, const Elf_Sym &Sym)
     : Undefined(SymbolBody::UndefinedElfKind, N,
                 Sym.getBinding() == llvm::ELF::STB_WEAK, Sym.getVisibility(),
                 Sym.getType() == llvm::ELF::STT_TLS),
       Sym(Sym) {}
 
 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);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);

ELF/Target.cpp

 //
 // Refer the ELF spec for the single letter varaibles, S, A or P, used
 // in this file. SA is S+A.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Target.h"
 #include "Error.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "Symbols.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Object/ELF.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/ELF.h"
 
 using namespace llvm;

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
-#include "OutputSections.h"
+#include "Segments.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/StringSaver.h"
private:
   void scanRelocs(InputSectionBase<ELFT> &S, const Elf_Shdr &RelSec);
   void updateRelro(Elf_Phdr *Cur, Elf_Phdr *GnuRelroPhdr, uintX_t VA);
   void assignAddresses();
   void buildSectionMap();
   void openFile(StringRef OutputPath);
   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();
   }
   bool isOutputDynamic() const {
     return !Symtab.getSharedFiles().empty() || Config->Shared;
   }
   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;
   std::vector<Elf_Phdr> Phdrs;
 
   uintX_t FileSize;
   uintX_t SectionHeaderOff;
 
-  llvm::StringMap<llvm::StringRef> InputToOutputSection;
+  llvm::StringMap<llvm::StringRef> InputToSegment;
 };
 } // anonymous namespace
 
 template <class ELFT> static bool shouldUseRela() {
   ELFKind K = cast<ELFFileBase<ELFT>>(Config->FirstElf)->getELFKind();
   return K == ELF64LEKind || K == ELF64BEKind;
 }
 
return StringSwitch<int>(SectionName)
            .Case(".tocbss", 0)
            .Case(".branch_lt", 2)
            .Case(".toc", 3)
            .Case(".toc1", 4)
            .Case(".opd", 5)
            .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)
     return true;
   uint32_t Type = Sec->getType();
   if (Type == SHT_INIT_ARRAY || Type == SHT_FINI_ARRAY ||
       Type == SHT_PREINIT_ARRAY)
     return true;
   if (Sec == Out<ELFT>::GotPlt)
     return Config->ZNow;
   if (Sec == Out<ELFT>::Dynamic || Sec == Out<ELFT>::Got)
     return true;
   StringRef S = Sec->getName();
   return S == ".data.rel.ro" || S == ".ctors" || S == ".dtors" || S == ".jcr" ||
          S == ".eh_frame";
 }
 
 // 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();
   uintX_t BFlags = B->getFlags();
 
   // Allocatable sections go first to reduce the total PT_LOAD size and
   // so debug info doesn't change addresses in actual code.
   bool AIsAlloc = AFlags & SHF_ALLOC;
static bool compareSegments(SegmentBase<ELFT> *A, SegmentBase<ELFT> *B) {
   // within the same PT_LOAD.
   if (Config->EMachine == EM_PPC64)
     return getPPC64SectionRank(A->getName()) <
            getPPC64SectionRank(B->getName());
 
   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;
 }
 
 // Until this function is called, common symbols do not belong to any section.
 // This function adds them to end of BSS section.
 template <class ELFT>
 void Writer<ELFT>::addCommonSymbols(std::vector<DefinedCommon<ELFT> *> &Syms) {
for (SharedSymbol<ELFT> *C : Syms) {
     Off = RoundUpToAlignment(Off, Align);
     C->OffsetInBSS = Off;
     Off += Sym.st_size;
   }
   Out<ELFT>::Bss->setSize(Off);
 }
 
 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."))
     return ".text";
   if (S.startswith(".rodata."))
     return ".rodata";
   if (S.startswith(".data.rel.ro"))
     return ".data.rel.ro";
void reportDiscarded(InputSectionBase<ELFT> *IS,
   llvm::errs() << "removing unused section from '" << IS->getSectionName()
                << "' in file '" << File->getName() << "'\n";
 }
 
 template <class ELFT>
 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;
 }
 
 // A statically linked executable will have rel[a].plt section
 // to hold R_[*]_IRELATIVE relocations.
 // The multi-arch libc will use these symbols to locate
 // these relocations at program startup time.
template <class ELFT> static bool includeInSymtab(const SymbolBody &B) {
   // Don't include synthetic symbols like __init_array_start in every output.
   if (auto *U = dyn_cast<DefinedAbsolute<ELFT>>(&B))
     if (&U->Sym == &DefinedAbsolute<ELFT>::IgnoreUndef)
       return false;
 
   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()) {
       if (isDiscarded(C)) {
         reportDiscarded(C, F);
         continue;
       }
       const Elf_Shdr *H = C->getSectionHdr();
       uintX_t OutFlags = H->sh_flags & ~SHF_GROUP;
       // For SHF_MERGE we create different output sections for each sh_entsize.
       // This makes each output section simple and keeps a single level
       // mapping from input to output.
       typename InputSectionBase<ELFT>::Kind K = C->SectionKind;
       uintX_t EntSize = K != InputSectionBase<ELFT>::Merge ? 0 : H->sh_entsize;
       uint32_t OutType = H->sh_type;
       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(
       {".preinit_array", SHT_PREINIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->InitArraySec =
       Map.lookup({".init_array", SHT_INIT_ARRAY, SHF_WRITE | SHF_ALLOC, 0});
   Out<ELFT>::Dynamic->FiniArraySec =
       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());
     } else {
       Symtab.addIgnored(Start);
       Symtab.addIgnored(End);
     }
   };
 
   AddStartEnd("__preinit_array_start", "__preinit_array_end",
               Out<ELFT>::Dynamic->PreInitArraySec);
   AddStartEnd("__init_array_start", "__init_array_end",
               Out<ELFT>::Dynamic->InitArraySec);
   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
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnored("__tls_get_addr");
 
if (isOutputDynamic() && includeInDynamicSymtab(*Body))
       Out<ELFT>::DynSymTab->addSymbol(Body);
   }
   addCommonSymbols(CommonSymbols);
   addSharedCopySymbols(SharedCopySymbols);
 
   // 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();
   }
 
   bool needsGot = !Out<ELFT>::Got->empty();
   // We add the .got section to the result for dynamic MIPS target because
   // its address and properties are mentioned in the .dynamic section.
   if (Config->EMachine == EM_MIPS)
     needsGot |= isOutputDynamic();
   // If we have a relocation that is relative to GOT (such as GOTOFFREL),
   // we need to emit a GOT even if it's empty.
   if (HasGotOffRel)
     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.
   // .dynamic section's finalizer may add strings to .dynstr,
   // so finalize that early.
   // Likewise, .dynsym is finalized early since that may fill up .gnu.hash.
   Out<ELFT>::Dynamic->finalize();
   if (isOutputDynamic())
     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),
   // store a pointer to it here so that we can use it later when processing
   // relocations.
   Out<ELFT>::Opd = Map.lookup({".opd", SHT_PROGBITS, SHF_WRITE | SHF_ALLOC, 0});
 }
 

 }
 
 // If a section name is valid as a C identifier (which is rare because of
 // the leading '.'), linkers are expected to define __start_<secname> and
 // __stop_<secname> symbols. They are at beginning and end of the section,
 // 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;
   StringSaver Saver(Alloc);
   StringRef Start = Saver.save("__start_" + S);
   StringRef Stop = Saver.save("__stop_" + S);
   if (Symtab.isUndefined(Start))
     Symtab.addSynthetic(Start, *Sec, 0);
   if (Symtab.isUndefined(Stop))
     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;
 }
 
 static uint32_t toPhdrFlags(uint64_t Flags) {
   uint32_t Ret = PF_R;
   if (Flags & SHF_WRITE)
     Ret |= PF_W;
   if (Flags & SHF_EXECINSTR)
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   setPhdr(&Phdrs[++PhdrIdx], PT_LOAD, PF_R, 0, Target->getVAStart(), FileOff,
           Target->getPageSize());
 
   Elf_Phdr GnuRelroPhdr = {};
   Elf_Phdr TlsPhdr{};
   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());
       bool InRelRo = Config->ZRelro && (Flags & PF_W) && isRelroSection(Sec);
       bool FirstNonRelRo = GnuRelroPhdr.p_type && !InRelRo && !RelroAligned;
       if (FirstNonRelRo || PH->p_flags != Flags) {
         VA = RoundUpToAlignment(VA, Target->getPageSize());
         FileOff = RoundUpToAlignment(FileOff, Target->getPageSize());
template <class ELFT> void Writer<ELFT>::assignAddresses() {
   // Fix up PT_INTERP as we now know the address of .interp section.
   if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
   // 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.
   DefinedAbsolute<ELFT>::End.st_value = VA;
 
   // Update __rel_iplt_start/__rel_iplt_end to wrap the
   // rela.plt section.
   if (Out<ELFT>::RelaPlt) {
template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
   int I = 2; // 2 for PT_PHDR and first PT_LOAD
   if (needsInterpSection())
     ++I;
   if (isOutputDynamic())
     ++I;
   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)
       Tls = true;
     uintX_t Flags = toPhdrFlags(Sec->getFlags());
     if (Last != Flags) {
       Last = Flags;
       ++I;
template <class ELFT> void Writer<ELFT>::writeHeader() {
   EHdr->e_entry = getEntryAddr();
   EHdr->e_phoff = sizeof(Elf_Ehdr);
   EHdr->e_shoff = SectionHeaderOff;
   EHdr->e_flags = getELFFlags();
   EHdr->e_ehsize = sizeof(Elf_Ehdr);
   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.
   memcpy(Buf + EHdr->e_phoff, &Phdrs[0], Phdrs.size() * sizeof(Phdrs[0]));
 
   // 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);
 }
 
 template <class ELFT> void Writer<ELFT>::openFile(StringRef Path) {
   ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(Path, FileSize, FileOutputBuffer::F_executable);
   error(BufferOrErr, Twine("failed to open ") + Path);
   Buffer = std::move(*BufferOrErr);
 }
 
 // Write section contents to a mmap'ed file.
 template <class ELFT> void Writer<ELFT>::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
 
   // 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());
 }
 
 template <class ELFT>
 typename ELFFile<ELFT>::uintX_t Writer<ELFT>::getEntryAddr() const {
   if (Config->EntrySym) {
     if (SymbolBody *E = Config->EntrySym->repl())
void Writer<ELFT>::setPhdr(Elf_Phdr *PH, uint32_t Type, uint32_t Flags,
   PH->p_vaddr = VA;
   PH->p_paddr = VA;
   PH->p_filesz = Size;
   PH->p_memsz = Size;
   PH->p_align = Align;
 }
 
 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();
   PH->p_paddr = From->getVA();
   PH->p_filesz = From->getSize();
   PH->p_memsz = From->getSize();
   PH->p_align = From->getAlign();
 }
 
 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);
 template void lld::elf2::writeResult<ELF32BE>(SymbolTable<ELF32BE> *Symtab);
 template void lld::elf2::writeResult<ELF64LE>(SymbolTable<ELF64LE> *Symtab);
 template void lld::elf2::writeResult<ELF64BE>(SymbolTable<ELF64BE> *Symtab);