Remove DefinedSynthetic

[• rafael]

Summary

With this we have a single section hierarchy. It is a bit less code, but the main advantage will be being able to handle

foo = symbol_in_obj;

in a linker script. Currently that fails since we try to find the output section of symbol_in_obj. With this we should be able to just return an InputSection from the expression.

[ruiu]

This is interesting. It seems almost neutral to me as it removes one class and instead introduces one class hierarchy. I wonder if this opens up other opportunities to simplify things. E.g. we have a bunch of lambdas in LinkerScript.cpp to compute addresses lazily. If you land this patch, can you simplify that, for example?

ELF/InputSection.h

38

It actually uses 64 bits, no? I don't think we need to use a bit field.

ELF/Symbols.cpp

48

Ah, okay, this.

262–267

Is this what clang-format formatted?

ELF/Symbols.h

178

->Repl is for ICF. Does ICF still work without that?

[grimar]

ELF/InputSection.cpp

226

Seems we going to have only one output section type.
May be then

bool InputSectionBase::classof(const SectionBase *S) {
 return S->kind() != Output;
}

[ruiu]

Let's try this one. LGTM. Please submit after addressing these minor comments.

ELF/InputSection.cpp

107

Nice to add a comment saying that -1 indicates the end of the section.

135–136

I would add this at the beginning of this function because this is the most common case.

ELF/InputSection.h

37

Please add a comment -- this class represents an ELF section, either it is an input section or an output section.

39

I think Output has a risk of name conflict. Maybe it should be OutputKind, though adding "Kind" to all five enums should be done in another patch.

79

Maybe we should initialize Live and Assigned bits too so that even if there's a bug we get a consistent behavior.

[• espindola]

297313

ELF/InputSection.h

 
 class DefinedRegular;
 class SyntheticSection;
 template <class ELFT> class EhFrameSection;
 class MergeSyntheticSection;
 template <class ELFT> class ObjectFile;
 class OutputSection;
 
-// This corresponds to a section of an input file.
-class InputSectionBase {
+class SectionBase {
 public:
-  enum Kind { Regular, EHFrame, Merge, Synthetic, };
+  enum Kind { Regular, EHFrame, Merge, Synthetic, Output };
 
   Kind kind() const { return (Kind)SectionKind; }
-  // The file this section is from.
-  InputFile *File;
-
-  ArrayRef<uint8_t> Data;
 
   StringRef Name;
 
   unsigned SectionKind : 3;
 
+  // The next two bit fields are only used by InputSectionBase, but we
+  // put them here so the struct packs better.
+
   // The garbage collector sets sections' Live bits.
   // If GC is disabled, all sections are considered live by default.
   unsigned Live : 1;     // for garbage collection
   unsigned Assigned : 1; // for linker script
 
   uint32_t Alignment;
 
   // These corresponds to the fields in Elf_Shdr.
   uint64_t Flags;
   uint64_t Entsize;
   uint32_t Type;
   uint32_t Link;
   uint32_t Info;
 
+  OutputSection *getOutputSection();
+  const OutputSection *getOutputSection() const {
+    return const_cast<SectionBase *>(this)->getOutputSection();
+  }
+
+  // Translate an offset in the input section to an offset in the output
+  // section.
+  uint64_t getOffset(uint64_t Offset) const;
+
+  uint64_t getOffset(const DefinedRegular &Sym) const;
+
+protected:
+  SectionBase(Kind SectionKind, StringRef Name, uint64_t Flags,
+              uint64_t Entsize, uint64_t Alignment, uint32_t Type,
+              uint32_t Info, uint32_t Link)
+      : Name(Name), SectionKind(SectionKind), Alignment(Alignment),
+        Flags(Flags), Entsize(Entsize), Type(Type), Link(Link), Info(Info) {}
+};
+
+// This corresponds to a section of an input file.
+class InputSectionBase : public SectionBase {
+public:
+  static bool classof(const SectionBase *S);
+
+  // The file this section is from.
+  InputFile *File;
+
+  ArrayRef<uint8_t> Data;
   uint64_t getOffsetInFile() const;
 
   static InputSectionBase Discarded;
 
   InputSectionBase()
-      : SectionKind(Regular), Live(false), Assigned(false), Repl(this) {
+      : SectionBase(Regular, "", /*Flags*/ 0, /*Entsize*/ 0, /*Alignment*/ 0,
+                    /*Type*/ 0,
+                    /*Info*/ 0, /*Link*/ 0),
+        Repl(this) {
+    Live = false;
+    Assigned = false;
     NumRelocations = 0;
     AreRelocsRela = false;
   }
 
   template <class ELFT>
   InputSectionBase(ObjectFile<ELFT> *File, const typename ELFT::Shdr *Header,
                    StringRef Name, Kind SectionKind);
 
public:
   InputSectionBase *Repl;
 
   // InputSections that are dependent on us (reverse dependency for GC)
   llvm::TinyPtrVector<InputSectionBase *> DependentSections;
 
   // Returns the size of this section (even if this is a common or BSS.)
   size_t getSize() const;
 
-  OutputSection *getOutputSection() const;
-
   template <class ELFT> ObjectFile<ELFT> *getFile() const;
 
   template <class ELFT> llvm::object::ELFFile<ELFT> getObj() const {
     return getFile<ELFT>()->getObj();
   }
 
-  uint64_t getOffset(const DefinedRegular &Sym) const;
-
   template <class ELFT> InputSectionBase *getLinkOrderDep() const;
-  // Translate an offset in the input section to an offset in the output
-  // section.
-  uint64_t getOffset(uint64_t Offset) const;
 
   template <class ELFT> void uncompress();
 
   // Returns a source location string. Used to construct an error message.
   template <class ELFT> std::string getLocation(uint64_t Offset);
 
   template <class ELFT> void relocate(uint8_t *Buf, uint8_t *BufEnd);
 
static_assert(sizeof(SectionPiece) == 2 * sizeof(size_t),
               "SectionPiece is too big");
 
 // This corresponds to a SHF_MERGE section of an input file.
 class MergeInputSection : public InputSectionBase {
 public:
   template <class ELFT>
   MergeInputSection(ObjectFile<ELFT> *F, const typename ELFT::Shdr *Header,
                     StringRef Name);
-  static bool classof(const InputSectionBase *S);
+  static bool classof(const SectionBase *S);
   void splitIntoPieces();
 
   // Mark the piece at a given offset live. Used by GC.
   void markLiveAt(uint64_t Offset) {
     assert(this->Flags & llvm::ELF::SHF_ALLOC);
     LiveOffsets.insert(Offset);
   }
 

 };
 
 // This corresponds to a .eh_frame section of an input file.
 class EhInputSection : public InputSectionBase {
 public:
   template <class ELFT>
   EhInputSection(ObjectFile<ELFT> *F, const typename ELFT::Shdr *Header,
                  StringRef Name);
-  static bool classof(const InputSectionBase *S);
+  static bool classof(const SectionBase *S);
   template <class ELFT> void split();
   template <class ELFT, class RelTy> void split(ArrayRef<RelTy> Rels);
 
   // Splittable sections are handled as a sequence of data
   // rather than a single large blob of data.
   std::vector<EhSectionPiece> Pieces;
   SyntheticSection *EHSec = nullptr;
 };
public:
   // Write this section to a mmap'ed file, assuming Buf is pointing to
   // beginning of the output section.
   template <class ELFT> void writeTo(uint8_t *Buf);
 
   // The offset from beginning of the output sections this section was assigned
   // to. The writer sets a value.
   uint64_t OutSecOff = 0;
 
-  static bool classof(const InputSectionBase *S);
+  static bool classof(const SectionBase *S);
 
   template <class ELFT> InputSectionBase *getRelocatedSection();
 
   template <class ELFT, class RelTy>
   void relocateNonAlloc(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   // Used by ICF.
   uint32_t Class[2] = {0, 0};

ELF/InputSection.cpp

static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File,
   return check(File->getObj().getSectionContents(Hdr));
 }
 
 InputSectionBase::InputSectionBase(InputFile *File, uint64_t Flags,
                                    uint32_t Type, uint64_t Entsize,
                                    uint32_t Link, uint32_t Info,
                                    uint64_t Alignment, ArrayRef<uint8_t> Data,
                                    StringRef Name, Kind SectionKind)
-    : File(File), Data(Data), Name(Name), SectionKind(SectionKind),
-      Live(!Config->GcSections || !(Flags & SHF_ALLOC)), Assigned(false),
-      Flags(Flags), Entsize(Entsize), Type(Type), Link(Link), Info(Info),
-      Repl(this) {
+    : SectionBase(SectionKind, Name, Flags, Entsize, Alignment, Type, Info,
+                  Link),
+      File(File), Data(Data), Repl(this) {
+  Live = !Config->GcSections || !(Flags & SHF_ALLOC);
+  Assigned = false;
   NumRelocations = 0;
   AreRelocsRela = false;
 
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraits.
   uint64_t V = std::max<uint64_t>(Alignment, 1);
   if (!isPowerOf2_64(V))
     fatal(toString(File) + ": section sh_addralign is not a power of 2");

 }
 
 uint64_t InputSectionBase::getOffsetInFile() const {
   const uint8_t *FileStart = (const uint8_t *)File->MB.getBufferStart();
   const uint8_t *SecStart = Data.begin();
   return SecStart - FileStart;
 }
 
-uint64_t InputSectionBase::getOffset(uint64_t Offset) const {
+uint64_t SectionBase::getOffset(uint64_t Offset) const {
   switch (kind()) {
+  case Output: {
+    auto *OS = cast<OutputSection>(this);
+    return Offset == uint64_t(-1) ? OS->Size : Offset;
+  }
   case Regular:
     return cast<InputSection>(this)->OutSecOff + Offset;
-  case Synthetic:
+  case Synthetic: {
+    auto *IS = cast<InputSection>(this);
     // For synthetic sections we treat offset -1 as the end of the section.
-    // The same approach is used for synthetic symbols (DefinedSynthetic).
-    return cast<InputSection>(this)->OutSecOff +
-           (Offset == uint64_t(-1) ? getSize() : Offset);
+    return IS->OutSecOff + (Offset == uint64_t(-1) ? IS->getSize() : Offset);
+  }
   case EHFrame:
     // The file crtbeginT.o has relocations pointing to the start of an empty
     // .eh_frame that is known to be the first in the link. It does that to
     // identify the start of the output .eh_frame.
     return Offset;
   case Merge:
     const MergeInputSection *MS = cast<MergeInputSection>(this);
     if (MS->MergeSec)
       return MS->MergeSec->OutSecOff + MS->getOffset(Offset);
     return MS->getOffset(Offset);
   }
   llvm_unreachable("invalid section kind");
 }
 
-OutputSection *InputSectionBase::getOutputSection() const {
+OutputSection *SectionBase::getOutputSection() {
   if (auto *MS = dyn_cast<MergeInputSection>(this))
     return MS->MergeSec ? MS->MergeSec->OutSec : nullptr;
   if (auto *EH = dyn_cast<EhInputSection>(this))
     return EH->EHSec->OutSec;
-  return OutSec;
+  if (auto *IS = dyn_cast<InputSection>(this))
+    return IS->OutSec;
+  return cast<OutputSection>(this);
 }
 
 // Uncompress section contents. Note that this function is called
 // from parallel_for_each, so it must be thread-safe.
 template <class ELFT> void InputSectionBase::uncompress() {
   Decompressor Dec = check(Decompressor::create(
       Name, toStringRef(Data), ELFT::TargetEndianness == llvm::support::little,
       ELFT::Is64Bits));
 
   size_t Size = Dec.getDecompressedSize();
   char *OutputBuf;
   {
     static std::mutex Mu;
     std::lock_guard<std::mutex> Lock(Mu);
     OutputBuf = BAlloc.Allocate<char>(Size);
   }
 
   if (Error E = Dec.decompress({OutputBuf, Size}))
     fatal(toString(this) +
           ": decompress failed: " + llvm::toString(std::move(E)));
   Data = ArrayRef<uint8_t>((uint8_t *)OutputBuf, Size);
 }
 
-uint64_t InputSectionBase::getOffset(const DefinedRegular &Sym) const {
+uint64_t SectionBase::getOffset(const DefinedRegular &Sym) const {
   return getOffset(Sym.Value);
 }
 
 template <class ELFT>
 InputSectionBase *InputSectionBase::getLinkOrderDep() const {
   if ((Flags & SHF_LINK_ORDER) && Link != 0)
     return getFile<ELFT>()->getSections()[Link];
   return nullptr;
: InputSectionBase(nullptr, Flags, Type,
                        /*Entsize*/ 0, /*Link*/ 0, /*Info*/ 0, Alignment, Data,
                        Name, K) {}
 
 template <class ELFT>
 InputSection::InputSection(elf::ObjectFile<ELFT> *F,
                            const typename ELFT::Shdr *Header, StringRef Name)
     : InputSectionBase(F, Header, Name, InputSectionBase::Regular) {}
 
-bool InputSection::classof(const InputSectionBase *S) {
-  return S->kind() == InputSectionBase::Regular ||
-         S->kind() == InputSectionBase::Synthetic;
+bool InputSection::classof(const SectionBase *S) {
+  return S->kind() == SectionBase::Regular ||
+         S->kind() == SectionBase::Synthetic;
+}
+
+bool InputSectionBase::classof(const SectionBase *S) {
+  return S->kind() != Output;
 }
 
 template <class ELFT> InputSectionBase *InputSection::getRelocatedSection() {
   assert(this->Type == SHT_RELA || this->Type == SHT_REL);
   ArrayRef<InputSectionBase *> Sections = this->getFile<ELFT>()->getSections();
   return Sections[this->Info];
 }
 
 // This is used for -r and --emit-relocs. We can't use memcpy to copy
 // relocations because we need to update symbol table offset and section index
 // for each relocation. So we copy relocations one by one.
 template <class ELFT, class RelTy>
 void InputSection::copyRelocations(uint8_t *Buf, ArrayRef<RelTy> Rels) {
   InputSectionBase *RelocatedSection = getRelocatedSection<ELFT>();
 
   // Loop is slow and have complexity O(N*M), where N - amount of
   // relocations and M - amount of symbols in symbol table.
   // That happens because getSymbolIndex(...) call below performs
if (Body.Type == STT_SECTION) {
       // section. This means we have to update the addend. That is
       // trivial for Elf_Rela, but for Elf_Rel we have to write to the
       // section data. We do that by adding to the Relocation vector.
 
       // .eh_frame is horribly special and can reference discarded sections. To
       // avoid having to parse and recreate .eh_frame, we just replace any
       // relocation in it pointing to discarded sections with R_*_NONE, which
       // hopefully creates a frame that is ignored at runtime.
-      InputSectionBase *Section = cast<DefinedRegular>(Body).Section;
+      SectionBase *Section = cast<DefinedRegular>(Body).Section;
       if (Section == &InputSection::Discarded) {
         P->setSymbolAndType(0, 0, false);
         continue;
       }
 
       if (Config->isRela()) {
-        P->r_addend += Body.getVA<ELFT>() - Section->OutSec->Addr;
+        P->r_addend += Body.getVA<ELFT>() - Section->getOutputSection()->Addr;
       } else if (Config->Relocatable) {
         const uint8_t *BufLoc = RelocatedSection->Data.begin() + Rel.r_offset;
         RelocatedSection->Relocations.push_back(
             {R_ABS, Type, Rel.r_offset, Target->getImplicitAddend(BufLoc, Type),
              &Body});
       }
     }
 
EhInputSection::EhInputSection(elf::ObjectFile<ELFT> *F,
                                StringRef Name)
     : InputSectionBase(F, Header, Name, InputSectionBase::EHFrame) {
   // Mark .eh_frame sections as live by default because there are
   // usually no relocations that point to .eh_frames. Otherwise,
   // the garbage collector would drop all .eh_frame sections.
   this->Live = true;
 }
 
-bool EhInputSection::classof(const InputSectionBase *S) {
+bool EhInputSection::classof(const SectionBase *S) {
   return S->kind() == InputSectionBase::EHFrame;
 }
 
 // Returns the index of the first relocation that points to a region between
 // Begin and Begin+Size.
 template <class IntTy, class RelTy>
 static unsigned getReloc(IntTy Begin, IntTy Size, const ArrayRef<RelTy> &Rels,
                          unsigned &RelocI) {
void MergeInputSection::splitIntoPieces() {
   else
     splitNonStrings(Data, EntSize);
 
   if (Config->GcSections && (this->Flags & SHF_ALLOC))
     for (uint64_t Off : LiveOffsets)
       this->getSectionPiece(Off)->Live = true;
 }
 
-bool MergeInputSection::classof(const InputSectionBase *S) {
+bool MergeInputSection::classof(const SectionBase *S) {
   return S->kind() == InputSectionBase::Merge;
 }
 
 // Do binary search to get a section piece at a given input offset.
 SectionPiece *MergeInputSection::getSectionPiece(uint64_t Offset) {
   auto *This = static_cast<const MergeInputSection *>(this);
   return const_cast<SectionPiece *>(This->getSectionPiece(Offset));
 }

ELF/LinkerScript.h

 // Later, we evaluate the expression by calling the function
 // with the value of special context variable ".".
 struct Expr {
   std::function<uint64_t(uint64_t)> Val;
   std::function<bool()> IsAbsolute;
 
   // If expression is section-relative the function below is used
   // to get the output section pointer.
-  std::function<const OutputSection *()> Section;
+  std::function<OutputSection *()> Section;
 
   uint64_t operator()(uint64_t Dot) const { return Val(Dot); }
   operator bool() const { return (bool)Val; }
 
   Expr(std::function<uint64_t(uint64_t)> Val, std::function<bool()> IsAbsolute,
-       std::function<const OutputSection *()> Section)
+       std::function<OutputSection *()> Section)
       : Val(Val), IsAbsolute(IsAbsolute), Section(Section) {}
   template <typename T>
   Expr(T V) : Expr(V, [] { return true; }, [] { return nullptr; }) {}
   Expr() : Expr(nullptr) {}
 };
 
 // Parses a linker script. Calling this function updates
 // Config and ScriptConfig.
struct MemoryRegion {
   uint64_t Offset;
   uint32_t Flags;
   uint32_t NegFlags;
 };
 
 class LinkerScriptBase {
 protected:
   ~LinkerScriptBase() = default;
+  OutputSection *Aether;
 
 public:
   virtual uint64_t getHeaderSize() = 0;
   virtual uint64_t getSymbolValue(const Twine &Loc, StringRef S) = 0;
   virtual bool isDefined(StringRef S) = 0;
   virtual bool isAbsolute(StringRef S) = 0;
-  virtual const OutputSection *getSymbolSection(StringRef S) = 0;
-  virtual const OutputSection *getOutputSection(const Twine &Loc,
-                                                StringRef S) = 0;
+  virtual OutputSection *getSymbolSection(StringRef S) = 0;
+  virtual OutputSection *getOutputSection(const Twine &Loc, StringRef S) = 0;
   virtual uint64_t getOutputSectionSize(StringRef S) = 0;
 };
 
 // ScriptConfiguration holds linker script parse results.
 struct ScriptConfiguration {
   // Used to assign addresses to sections.
   std::vector<std::unique_ptr<BaseCommand>> Commands;
 
public:
   void assignOffsets(OutputSectionCommand *Cmd);
   void placeOrphanSections();
   void assignAddresses(std::vector<PhdrEntry> &Phdrs);
   bool hasPhdrsCommands();
   uint64_t getHeaderSize() override;
   uint64_t getSymbolValue(const Twine &Loc, StringRef S) override;
   bool isDefined(StringRef S) override;
   bool isAbsolute(StringRef S) override;
-  const OutputSection *getSymbolSection(StringRef S) override;
-  const OutputSection *getOutputSection(const Twine &Loc, StringRef S) override;
+  OutputSection *getSymbolSection(StringRef S) override;
+  OutputSection *getOutputSection(const Twine &Loc, StringRef S) override;
   uint64_t getOutputSectionSize(StringRef S) override;
 
   std::vector<OutputSection *> *OutputSections;
 
   int getSectionIndex(StringRef Name);
 
 private:
   void assignSymbol(SymbolAssignment *Cmd, bool InSec = false);

ELF/LinkerScript.cpp

 
 template <class ELFT> static SymbolBody *addRegular(SymbolAssignment *Cmd) {
   Symbol *Sym;
   uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
   std::tie(Sym, std::ignore) = Symtab<ELFT>::X->insert(
       Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
       /*File*/ nullptr);
   Sym->Binding = STB_GLOBAL;
+  OutputSection *Sec =
+      Cmd->Expression.IsAbsolute() ? nullptr : Cmd->Expression.Section();
   replaceBody<DefinedRegular>(Sym, Cmd->Name, /*IsLocal=*/false, Visibility,
-                              STT_NOTYPE, 0, 0, nullptr, nullptr);
-  return Sym->body();
-}
-
-template <class ELFT> static SymbolBody *addSynthetic(SymbolAssignment *Cmd) {
-  Symbol *Sym;
-  uint8_t Visibility = Cmd->Hidden ? STV_HIDDEN : STV_DEFAULT;
-  const OutputSection *Sec =
-      ScriptConfig->HasSections ? nullptr : Cmd->Expression.Section();
-  std::tie(Sym, std::ignore) = Symtab<ELFT>::X->insert(
-      Cmd->Name, /*Type*/ 0, Visibility, /*CanOmitFromDynSym*/ false,
-      /*File*/ nullptr);
-  Sym->Binding = STB_GLOBAL;
-  replaceBody<DefinedSynthetic>(Sym, Cmd->Name, 0, Sec);
+                              STT_NOTYPE, 0, 0, Sec, nullptr);
   return Sym->body();
 }
 
 static bool isUnderSysroot(StringRef Path) {
   if (Config->Sysroot == "")
     return false;
   for (; !Path.empty(); Path = sys::path::parent_path(Path))
     if (sys::fs::equivalent(Config->Sysroot, Path))
void LinkerScript<ELFT>::assignSymbol(SymbolAssignment *Cmd, bool InSec) {
   if (Cmd->Name == ".") {
     setDot(Cmd->Expression, Cmd->Location, InSec);
     return;
   }
 
   if (!Cmd->Sym)
     return;
 
-  if (auto *Body = dyn_cast<DefinedSynthetic>(Cmd->Sym)) {
-    Body->Section = Cmd->Expression.Section();
-    if (Body->Section) {
-      uint64_t VA = 0;
-      if (Body->Section->Flags & SHF_ALLOC)
-        VA = Body->Section->Addr;
-      Body->Value = Cmd->Expression(Dot) - VA;
-    }
-    return;
-  }
-
-  cast<DefinedRegular>(Cmd->Sym)->Value = Cmd->Expression(Dot);
+  auto *Sym = cast<DefinedRegular>(Cmd->Sym);
+  Sym->Value = Cmd->Expression(Dot);
+  if (!Cmd->Expression.IsAbsolute()) {
+    Sym->Section = Cmd->Expression.Section();
+    if (auto *Sec = dyn_cast_or_null<OutputSection>(Sym->Section))
+      if (Sec->Flags & SHF_ALLOC)
+        Sym->Value -= Sec->Addr;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::addSymbol(SymbolAssignment *Cmd) {
   if (Cmd->Name == ".")
     return;
 
   // If a symbol was in PROVIDE(), we need to define it only when
   // it is a referenced undefined symbol.
   SymbolBody *B = Symtab<ELFT>::X->find(Cmd->Name);
   if (Cmd->Provide && (!B || B->isDefined()))
     return;
 
-  // Otherwise, create a new symbol if one does not exist or an
-  // undefined one does exist.
-  if (Cmd->Expression.IsAbsolute())
-    Cmd->Sym = addRegular<ELFT>(Cmd);
-  else
-    Cmd->Sym = addSynthetic<ELFT>(Cmd);
 
   // If there are sections, then let the value be assigned later in
   // `assignAddresses`.
   if (!ScriptConfig->HasSections)
     assignSymbol(Cmd);
 }
 
 bool SymbolAssignment::classof(const BaseCommand *C) {
for (InputSectionBase *S : Cmd->Sections)
       Ret.push_back(static_cast<InputSectionBase *>(S));
   }
 
   return Ret;
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::processCommands(OutputSectionFactory &Factory) {
+  // A symbol can be assigned before any section is mentioned in the linker
+  // script. In an DSO, the symbol values are addresses, so the only important
+  // section values are:
+  // * SHN_UNDEF
+  // * SHN_ABS
+  // * Any value meaning a regular section.
+  // To handle that, create a dummy aether section that fills the void before
+  // the linker scripts switches to another section. It has an index of one
+  // which will map to whatever the first actual section is.
+  Aether = make<OutputSection>("", 0, SHF_ALLOC);
+  Aether->SectionIndex = 1;
+  CurOutSec = Aether;
+
   for (unsigned I = 0; I < Opt.Commands.size(); ++I) {
     auto Iter = Opt.Commands.begin() + I;
     const std::unique_ptr<BaseCommand> &Base1 = *Iter;
 
     // Handle symbol assignments outside of any output section.
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       addSymbol(Cmd);
       continue;
if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base1.get())) {
           S->Alignment = Subalign;
       }
 
       // Add input sections to an output section.
       for (InputSectionBase *S : V)
         Factory.addInputSec<ELFT>(S, Cmd->Name);
     }
   }
+  CurOutSec = nullptr;
 }
 
 // Add sections that didn't match any sections command.
 template <class ELFT>
 void LinkerScript<ELFT>::addOrphanSections(OutputSectionFactory &Factory) {
   for (InputSectionBase *S : InputSections)
     if (S->Live && !S->OutSec)
       Factory.addInputSec<ELFT>(S, getOutputSectionName(S->Name));
for (OutputSection *Sec : *OutputSections) {
     CmdIndex = (Pos - Opt.Commands.begin()) + 1;
   }
 }
 
 template <class ELFT>
 void LinkerScript<ELFT>::assignAddresses(std::vector<PhdrEntry> &Phdrs) {
   // Assign addresses as instructed by linker script SECTIONS sub-commands.
   Dot = 0;
-
-  // A symbol can be assigned before any section is mentioned in the linker
-  // script. In an DSO, the symbol values are addresses, so the only important
-  // section values are:
-  // * SHN_UNDEF
-  // * SHN_ABS
-  // * Any value meaning a regular section.
-  // To handle that, create a dummy aether section that fills the void before
-  // the linker scripts switches to another section. It has an index of one
-  // which will map to whatever the first actual section is.
-  auto *Aether = make<OutputSection>("", 0, SHF_ALLOC);
-  Aether->SectionIndex = 1;
   switchTo(Aether);
 
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base.get())) {
       assignSymbol(Cmd);
       continue;
     }
 
template <class ELFT> int LinkerScript<ELFT>::getSectionIndex(StringRef Name) {
   return INT_MAX;
 }
 
 template <class ELFT> bool LinkerScript<ELFT>::hasPhdrsCommands() {
   return !Opt.PhdrsCommands.empty();
 }
 
 template <class ELFT>
-const OutputSection *LinkerScript<ELFT>::getOutputSection(const Twine &Loc,
-                                                          StringRef Name) {
+OutputSection *LinkerScript<ELFT>::getOutputSection(const Twine &Loc,
   static OutputSection FakeSec("", 0, 0);
 
   for (OutputSection *Sec : *OutputSections)
     if (Sec->Name == Name)
       return Sec;
 
   error(Loc + ": undefined section " + Name);
   return &FakeSec;
template <class ELFT> bool LinkerScript<ELFT>::isAbsolute(StringRef S) {
   auto *DR = dyn_cast_or_null<DefinedRegular>(Sym);
   return DR && !DR->Section;
 }
 
 // Gets section symbol belongs to. Symbol "." doesn't belong to any
 // specific section but isn't absolute at the same time, so we try
 // to find suitable section for it as well.
 template <class ELFT>
-const OutputSection *LinkerScript<ELFT>::getSymbolSection(StringRef S) {
+OutputSection *LinkerScript<ELFT>::getSymbolSection(StringRef S) {
   if (SymbolBody *Sym = Symtab<ELFT>::X->find(S))
     return Sym->getOutputSection<ELFT>();
   return CurOutSec;
 }
 
 // Returns indices of ELF headers containing specific section, identified
 // by Name. Each index is a zero based number of ELF header listed within
 // PHDRS {} script block.
Expr ScriptParser::readExpr() {
   Expr E = readExpr1(readPrimary(), 0);
   InExpr = Orig;
   return E;
 }
 
 static Expr combine(StringRef Op, Expr L, Expr R) {
   auto IsAbs = [=] { return L.IsAbsolute() && R.IsAbsolute(); };
   auto GetOutSec = [=] {
-    const OutputSection *S = L.Section();
+    OutputSection *S = L.Section();
     return S ? S : R.Section();
   };
 
   if (Op == "*")
     return [=](uint64_t Dot) { return L(Dot) * R(Dot); };
   if (Op == "/") {
     return [=](uint64_t Dot) -> uint64_t {
       uint64_t RHS = R(Dot);

ELF/MarkLive.cpp

static void resolveReloc(InputSectionBase &Sec, RelT &Rel,
                          std::function<void(ResolvedReloc)> Fn) {
   SymbolBody &B = Sec.getFile<ELFT>()->getRelocTargetSym(Rel);
   if (auto *D = dyn_cast<DefinedRegular>(&B)) {
     if (!D->Section)
       return;
     typename ELFT::uint Offset = D->Value;
     if (D->isSection())
       Offset += getAddend<ELFT>(Sec, Rel);
-    Fn({D->Section->Repl, Offset});
+    Fn({cast<InputSectionBase>(D->Section)->Repl, Offset});
   } else if (auto *U = dyn_cast<Undefined>(&B)) {
     for (InputSectionBase *Sec : CNamedSections.lookup(U->getName()))
       Fn({Sec, 0});
   }
 }
 
 // Calls Fn for each section that Sec refers to via relocations.
 template <class ELFT>
auto Enqueue = [&](ResolvedReloc R) {
     R.Sec->Live = true;
     // Add input section to the queue.
     if (InputSection *S = dyn_cast<InputSection>(R.Sec))
       Q.push_back(S);
   };
 
   auto MarkSymbol = [&](const SymbolBody *Sym) {
     if (auto *D = dyn_cast_or_null<DefinedRegular>(Sym))
-      Enqueue({D->Section, D->Value});
+      Enqueue({cast<InputSectionBase>(D->Section), D->Value});
   };
 
   // Add GC root symbols.
   MarkSymbol(Symtab<ELFT>::X->find(Config->Entry));
   MarkSymbol(Symtab<ELFT>::X->find(Config->Init));
   MarkSymbol(Symtab<ELFT>::X->find(Config->Fini));
   for (StringRef S : Config->Undefined)
     MarkSymbol(Symtab<ELFT>::X->find(S));

ELF/OutputSections.h

 //===- OutputSections.h -----------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_OUTPUT_SECTIONS_H
 #define LLD_ELF_OUTPUT_SECTIONS_H
 
 #include "Config.h"
+#include "InputSection.h"
 #include "Relocations.h"
 
 #include "lld/Core/LLVM.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf {

 template <class ELFT> class SharedFile;
 class SharedSymbol;
 class DefinedRegular;
 
 // This represents a section in an output file.
 // It is composed of multiple InputSections.
 // The writer creates multiple OutputSections and assign them unique,
 // non-overlapping file offsets and VAs.
-class OutputSection final {
+class OutputSection final : public SectionBase {
 public:
   OutputSection(StringRef Name, uint32_t Type, uint64_t Flags);
 
+  static bool classof(const SectionBase *S) {
+    return S->kind() == SectionBase::Output;
+  }
+
   uint64_t getLMA() const { return Addr + LMAOffset; }
   template <typename ELFT> void writeHeaderTo(typename ELFT::Shdr *SHdr);
 
   unsigned SectionIndex;
 
   uint32_t getPhdrFlags() const;
 
   void updateAlignment(uint32_t Val) {
     if (Val > Alignment)
       Alignment = Val;
   }
 
   // If true, this section will be page aligned on disk.
   // Typically the first section of each PT_LOAD segment has this flag.
   bool PageAlign = false;
 
   // Pointer to the first section in PT_LOAD segment, which this section
   // also resides in. This field is used to correctly compute file offset
   // of a section. When two sections share the same load segment, difference
   // between their file offsets should be equal to difference between their
   // virtual addresses. To compute some section offset we use the following
   // formula: Off = Off_first + VA - VA_first.
   OutputSection *FirstInPtLoad = nullptr;
 
-  StringRef Name;
-
   // The following fields correspond to Elf_Shdr members.
   uint64_t Size = 0;
-  uint64_t Entsize = 0;
   uint64_t Offset = 0;
-  uint64_t Flags = 0;
   uint64_t LMAOffset = 0;
   uint64_t Addr = 0;
-  uint32_t Alignment = 0;
   uint32_t ShName = 0;
-  uint32_t Type = 0;
-  uint32_t Info = 0;
-  uint32_t Link = 0;
 
   void addSection(InputSectionBase *C);
   void sort(std::function<int(InputSectionBase *S)> Order);
   void sortInitFini();
   void sortCtorsDtors();
   template <class ELFT> void writeTo(uint8_t *Buf);
   template <class ELFT> void finalize();
   template <class ELFT> void assignOffsets();

ELF/OutputSections.cpp

void OutputSection::writeHeaderTo(typename ELFT::Shdr *Shdr) {
   Shdr->sh_info = Info;
   Shdr->sh_link = Link;
   Shdr->sh_addr = Addr;
   Shdr->sh_size = Size;
   Shdr->sh_name = ShName;
 }
 
 OutputSection::OutputSection(StringRef Name, uint32_t Type, uint64_t Flags)
-    : Name(Name), Flags(Flags), Alignment(1), Type(Type) {}
+    : SectionBase(Output, Name, Flags, /*Entsize*/ 0, /*Alignment*/ 1, Type,
+                  /*Info*/ 0,
+                  /*Link*/ 0) {}
 
 template <typename ELFT>
 static bool compareByFilePosition(InputSection *A, InputSection *B) {
   // Synthetic doesn't have link order dependecy, stable_sort will keep it last
   if (A->kind() == InputSectionBase::Synthetic ||
       B->kind() == InputSectionBase::Synthetic)
     return false;
   auto *LA = cast<InputSection>(A->template getLinkOrderDep<ELFT>());

ELF/SymbolTable.h

public:
 
   Symbol *addUndefined(StringRef Name);
   Symbol *addUndefined(StringRef Name, bool IsLocal, uint8_t Binding,
                        uint8_t StOther, uint8_t Type, bool CanOmitFromDynSym,
                        InputFile *File);
 
   Symbol *addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
                      uint64_t Value, uint64_t Size, uint8_t Binding,
-                     InputSectionBase *Section, InputFile *File);
-
-  Symbol *addSynthetic(StringRef N, const OutputSection *Section,
-                       uint64_t Value, uint8_t StOther);
+                     SectionBase *Section, InputFile *File);
 
   void addShared(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
                  const typename ELFT::Verdef *Verdef);
 
   void addLazyArchive(ArchiveFile *F, const llvm::object::Archive::Symbol S);
   void addLazyObject(StringRef Name, LazyObjectFile &Obj);
   Symbol *addBitcode(StringRef Name, uint8_t Binding, uint8_t StOther,
                      uint8_t Type, bool CanOmitFromDynSym, BitcodeFile *File);

ELF/SymbolTable.cpp

 static void reportDuplicate(SymbolBody *Existing, InputSectionBase *ErrSec,
                             typename ELFT::uint ErrOffset) {
   DefinedRegular *D = dyn_cast<DefinedRegular>(Existing);
   if (!D || !D->Section || !ErrSec) {
     reportDuplicate(Existing, ErrSec ? ErrSec->getFile<ELFT>() : nullptr);
     return;
   }
 
-  std::string OldLoc = D->Section->template getLocation<ELFT>(D->Value);
+  std::string OldLoc =
+      cast<InputSectionBase>(D->Section)->template getLocation<ELFT>(D->Value);
   std::string NewLoc = ErrSec->getLocation<ELFT>(ErrOffset);
 
   print(NewLoc + ": duplicate symbol '" + toString(*Existing) + "'");
   print(OldLoc + ": previous definition was here");
 }
 
 template <typename ELFT>
-Symbol *
-SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther, uint8_t Type,
-                              uint64_t Value, uint64_t Size, uint8_t Binding,
-                              InputSectionBase *Section, InputFile *File) {
+Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
+                                      uint8_t Type, uint64_t Value,
+                                      uint64_t Size, uint8_t Binding,
+                                      SectionBase *Section, InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, Binding,
                                           Section == nullptr, Value);
   if (Cmp > 0)
     replaceBody<DefinedRegular>(S, Name, /*IsLocal=*/false, StOther, Type,
                                 Value, Size, Section, File);
   else if (Cmp == 0)
-    reportDuplicate<ELFT>(S->body(), Section, Value);
-  return S;
-}
-
-template <typename ELFT>
-Symbol *SymbolTable<ELFT>::addSynthetic(StringRef N,
-                                        const OutputSection *Section,
-                                        uint64_t Value, uint8_t StOther) {
-  Symbol *S;
-  bool WasInserted;
-  std::tie(S, WasInserted) = insert(N, STT_NOTYPE, getVisibility(StOther),
-                                    /*CanOmitFromDynSym*/ false, nullptr);
-  int Cmp = compareDefinedNonCommon<ELFT>(S, WasInserted, STB_GLOBAL,
-                                          /*IsAbsolute*/ false, /*Value*/ 0);
-  if (Cmp > 0)
-    replaceBody<DefinedSynthetic>(S, N, Value, Section);
-  else if (Cmp == 0)
-    reportDuplicate(S->body(), nullptr);
+    reportDuplicate<ELFT>(S->body(),
+                          dyn_cast_or_null<InputSectionBase>(Section), Value);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *File, StringRef Name,
                                   const Elf_Sym &Sym,
                                   const typename ELFT::Verdef *Verdef) {
   // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT

ELF/Symbols.h

 // The base class for real symbol classes.
 class SymbolBody {
 public:
   enum Kind {
     DefinedFirst,
     DefinedRegularKind = DefinedFirst,
     SharedKind,
     DefinedCommonKind,
-    DefinedSyntheticKind,
-    DefinedLast = DefinedSyntheticKind,
+    DefinedLast = DefinedCommonKind,
     UndefinedKind,
     LazyArchiveKind,
     LazyObjectKind,
   };
 
   SymbolBody(Kind K) : SymbolKind(K) {}
 
   Symbol *symbol();
public:
   template <class ELFT> typename ELFT::uint getVA(int64_t Addend = 0) const;
 
   template <class ELFT> typename ELFT::uint getGotOffset() const;
   template <class ELFT> typename ELFT::uint getGotVA() const;
   template <class ELFT> typename ELFT::uint getGotPltOffset() const;
   template <class ELFT> typename ELFT::uint getGotPltVA() const;
   template <class ELFT> typename ELFT::uint getPltVA() const;
   template <class ELFT> typename ELFT::uint getSize() const;
-  template <class ELFT> const OutputSection *getOutputSection() const;
+  template <class ELFT> OutputSection *getOutputSection() const;
 
   // The file from which this symbol was created.
   InputFile *File = nullptr;
 
   uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
public:
 
   uint64_t Size;
 };
 
 // Regular defined symbols read from object file symbol tables.
 class DefinedRegular : public Defined {
 public:
   DefinedRegular(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
-                 uint64_t Value, uint64_t Size, InputSectionBase *Section,
+                 uint64_t Value, uint64_t Size, SectionBase *Section,
                  InputFile *File)
       : Defined(SymbolBody::DefinedRegularKind, Name, IsLocal, StOther, Type),
-        Value(Value), Size(Size),
-        Section(Section ? Section->Repl : NullInputSection) {
+        Value(Value), Size(Size), Section(Section) {
     this->File = File;
   }
 
   // Return true if the symbol is a PIC function.
   template <class ELFT> bool isMipsPIC() const;
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == SymbolBody::DefinedRegularKind;
   }
 
   uint64_t Value;
   uint64_t Size;
-
-  // The input section this symbol belongs to. Notice that this is
-  // a reference to a pointer. We are using two levels of indirections
-  // because of ICF. If ICF decides two sections need to be merged, it
-  // manipulates this Section pointers so that they point to the same
-  // section. This is a bit tricky, so be careful to not be confused.
-  // If this is null, the symbol is an absolute symbol.
-  InputSectionBase *&Section;
-
-private:
-  static InputSectionBase *NullInputSection;
-};
-
-// 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.
-// If Section is null, this symbol is relative to the image base.
-class DefinedSynthetic : public Defined {
-public:
-  DefinedSynthetic(StringRef Name, uint64_t Value, const OutputSection *Section)
-      : Defined(SymbolBody::DefinedSyntheticKind, Name, /*IsLocal=*/false,
-                llvm::ELF::STV_HIDDEN, 0 /* Type */),
-        Value(Value), Section(Section) {}
-
-  static bool classof(const SymbolBody *S) {
-    return S->kind() == SymbolBody::DefinedSyntheticKind;
-  }
-
-  uint64_t Value;
-  const OutputSection *Section;
+  SectionBase *Section;
 };
 
 class Undefined : public SymbolBody {
 public:
   Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther, uint8_t Type,
             InputFile *F);
 
   static bool classof(const SymbolBody *S) {
public:
   LazyObjectFile *file() { return (LazyObjectFile *)this->File; }
   InputFile *fetch();
 };
 
 // Some linker-generated symbols need to be created as
 // DefinedRegular symbols.
 struct ElfSym {
   // The content for _etext and etext symbols.
-  static DefinedSynthetic *Etext;
-  static DefinedSynthetic *Etext2;
+  static DefinedRegular *Etext;
+  static DefinedRegular *Etext2;
 
   // The content for _edata and edata symbols.
-  static DefinedSynthetic *Edata;
-  static DefinedSynthetic *Edata2;
+  static DefinedRegular *Edata;
+  static DefinedRegular *Edata2;
 
   // The content for _end and end symbols.
-  static DefinedSynthetic *End;
-  static DefinedSynthetic *End2;
+  static DefinedRegular *End;
+  static DefinedRegular *End2;
 
   // The content for _gp_disp/__gnu_local_gp symbols for MIPS target.
   static DefinedRegular *MipsGpDisp;
   static DefinedRegular *MipsLocalGp;
   static DefinedRegular *MipsGp;
 };
 
 // A real symbol object, SymbolBody, is usually stored within a Symbol. There's
struct Symbol {
 
   bool includeInDynsym() const;
   uint8_t computeBinding() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   // This field is used to store the Symbol's SymbolBody. This instantiation of
   // AlignedCharArrayUnion gives us a struct with a char array field that is
   // large and aligned enough to store any derived class of SymbolBody.
-  llvm::AlignedCharArrayUnion<DefinedCommon, DefinedRegular, DefinedSynthetic,
-                              Undefined, SharedSymbol, LazyArchive, LazyObject>
+  llvm::AlignedCharArrayUnion<DefinedCommon, DefinedRegular, Undefined,
+                              SharedSymbol, LazyArchive, LazyObject>
       Body;
 
   SymbolBody *body() { return reinterpret_cast<SymbolBody *>(Body.buffer); }
   const SymbolBody *body() const { return const_cast<Symbol *>(this)->body(); }
 };
 
 void printTraceSymbol(Symbol *Sym);
 

ELF/Symbols.cpp

 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;
 
-InputSectionBase *DefinedRegular::NullInputSection;
-
-DefinedSynthetic *ElfSym::Etext;
-DefinedSynthetic *ElfSym::Etext2;
-DefinedSynthetic *ElfSym::Edata;
-DefinedSynthetic *ElfSym::Edata2;
-DefinedSynthetic *ElfSym::End;
-DefinedSynthetic *ElfSym::End2;
+DefinedRegular *ElfSym::Etext;
+DefinedRegular *ElfSym::Etext2;
+DefinedRegular *ElfSym::Edata;
+DefinedRegular *ElfSym::Edata2;
+DefinedRegular *ElfSym::End;
+DefinedRegular *ElfSym::End2;
 DefinedRegular *ElfSym::MipsGpDisp;
 DefinedRegular *ElfSym::MipsLocalGp;
 DefinedRegular *ElfSym::MipsGp;
 
 template <class ELFT>
 static typename ELFT::uint getSymVA(const SymbolBody &Body, int64_t &Addend) {
   switch (Body.kind()) {
-  case SymbolBody::DefinedSyntheticKind: {
-    auto &D = cast<DefinedSynthetic>(Body);
-    const OutputSection *Sec = D.Section;
-    if (!Sec)
-      return D.Value;
-    if (D.Value == uint64_t(-1))
-      return Sec->Addr + Sec->Size;
-    return Sec->Addr + D.Value;
-  }
   case SymbolBody::DefinedRegularKind: {
     auto &D = cast<DefinedRegular>(Body);
-    InputSectionBase *IS = D.Section;
+    SectionBase *IS = D.Section;
+    if (auto *ISB = dyn_cast_or_null<InputSectionBase>(IS))
+      IS = ISB->Repl;
 
     // 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 (IS == &InputSection::Discarded)
       return 0;
 
if (const auto *C = dyn_cast<DefinedCommon>(this))
     return C->Size;
   if (const auto *DR = dyn_cast<DefinedRegular>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol>(this))
     return S->getSize<ELFT>();
   return 0;
 }
 
-template <class ELFT>
-const OutputSection *SymbolBody::getOutputSection() const {
+template <class ELFT> OutputSection *SymbolBody::getOutputSection() const {
   if (auto *S = dyn_cast<DefinedRegular>(this)) {
     if (S->Section)
       return S->Section->getOutputSection();
     return nullptr;
   }
 
   if (isa<SharedSymbol>(this))
     return nullptr;
 
   if (isa<DefinedCommon>(this)) {
     if (Config->DefineCommon)
       return In<ELFT>::Common->OutSec;
     return nullptr;
   }
 
-  if (auto *S = dyn_cast<DefinedSynthetic>(this))
-    return S->Section;
   return nullptr;
 }
 
 // If a symbol name contains '@', the characters after that is
 // a symbol version name. This function parses that.
 void SymbolBody::parseSymbolVersion() {
   StringRef S = getName();
   size_t Pos = S.find('@');

 Defined::Defined(Kind K, StringRefZ Name, bool IsLocal, uint8_t StOther,
                  uint8_t Type)
     : SymbolBody(K, Name, IsLocal, StOther, Type) {}
 
 template <class ELFT> bool DefinedRegular::isMipsPIC() const {
   if (!Section || !isFunc())
     return false;
   return (this->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
-         (Section->getFile<ELFT>()->getObj().getHeader()->e_flags &
+         (cast<InputSectionBase>(Section)
+              ->template getFile<ELFT>()
+              ->getObj()
+              .getHeader()
+              ->e_flags &
           EF_MIPS_PIC);
 }
 
 Undefined::Undefined(StringRefZ Name, bool IsLocal, uint8_t StOther,
                      uint8_t Type, InputFile *File)
     : SymbolBody(SymbolBody::UndefinedKind, Name, IsLocal, StOther, Type) {
   this->File = File;
 }
 

 template uint64_t SymbolBody::template getPltVA<ELF64LE>() const;
 template uint64_t SymbolBody::template getPltVA<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getSize<ELF32LE>() const;
 template uint32_t SymbolBody::template getSize<ELF32BE>() const;
 template uint64_t SymbolBody::template getSize<ELF64LE>() const;
 template uint64_t SymbolBody::template getSize<ELF64BE>() const;
 
-template const OutputSection *
-    SymbolBody::template getOutputSection<ELF32LE>() const;
-template const OutputSection *
-    SymbolBody::template getOutputSection<ELF32BE>() const;
-template const OutputSection *
-    SymbolBody::template getOutputSection<ELF64LE>() const;
-template const OutputSection *
-    SymbolBody::template getOutputSection<ELF64BE>() const;
+template OutputSection *SymbolBody::template getOutputSection<ELF32LE>() const;
+template OutputSection *SymbolBody::template getOutputSection<ELF32BE>() const;
+template OutputSection *SymbolBody::template getOutputSection<ELF64LE>() const;
+template OutputSection *SymbolBody::template getOutputSection<ELF64BE>() const;
 
 template bool DefinedRegular::template isMipsPIC<ELF32LE>() const;
 template bool DefinedRegular::template isMipsPIC<ELF32BE>() const;
 template bool DefinedRegular::template isMipsPIC<ELF64LE>() const;
 template bool DefinedRegular::template isMipsPIC<ELF64BE>() const;
 
 template uint64_t SharedSymbol::template getAlignment<ELF32LE>() const;
 template uint64_t SharedSymbol::template getAlignment<ELF32BE>() const;
 template uint64_t SharedSymbol::template getAlignment<ELF64LE>() const;
 template uint64_t SharedSymbol::template getAlignment<ELF64BE>() const;

ELF/SyntheticSections.cpp

bool EhFrameSection<ELFT>::isFdeLive(EhSectionPiece &Piece,
   unsigned FirstRelI = Piece.FirstRelocation;
   if (FirstRelI == (unsigned)-1)
     return false;
   const RelTy &Rel = Rels[FirstRelI];
   SymbolBody &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
   auto *D = dyn_cast<DefinedRegular>(&B);
   if (!D || !D->Section)
     return false;
-  InputSectionBase *Target = D->Section->Repl;
+  auto *Target =
+      cast<InputSectionBase>(cast<InputSectionBase>(D->Section)->Repl);
   return Target && Target->Live;
 }
 
 // .eh_frame is a sequence of CIE or FDE records. In general, there
 // is one CIE record per input object file which is followed by
 // a list of FDEs. This function searches an existing CIE or create a new
 // one and associates FDEs to the CIE.
 template <class ELFT>

 template <class ELFT>
 size_t SymbolTableSection<ELFT>::getSymbolIndex(SymbolBody *Body) {
   auto I = llvm::find_if(Symbols, [&](const SymbolTableEntry &E) {
     if (E.Symbol == Body)
       return true;
     // This is used for -r, so we have to handle multiple section
     // symbols being combined.
     if (Body->Type == STT_SECTION && E.Symbol->Type == STT_SECTION)
-      return cast<DefinedRegular>(Body)->Section->OutSec ==
-             cast<DefinedRegular>(E.Symbol)->Section->OutSec;
+      return cast<DefinedRegular>(Body)->Section->getOutputSection() ==
+             cast<DefinedRegular>(E.Symbol)->Section->getOutputSection();
     return false;
   });
   if (I == Symbols.end())
     return 0;
   return I - Symbols.begin() + 1;
 }
 
 // Write the internal symbol table contents to the output symbol table.

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   if (In<ELFT>::SymTab)
     Add(In<ELFT>::SymTab);
   Add(In<ELFT>::ShStrTab);
   if (In<ELFT>::StrTab)
     Add(In<ELFT>::StrTab);
 }
 
 template <class ELFT>
-static bool shouldKeepInSymtab(InputSectionBase *Sec, StringRef SymName,
+static bool shouldKeepInSymtab(SectionBase *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile() || B.isSection())
     return false;
 
   // If sym references a section in a discarded group, don't keep it.
   if (Sec == &InputSection::Discarded)
     return false;
 

 }
 
 template <class ELFT> static bool includeInSymtab(const SymbolBody &B) {
   if (!B.isLocal() && !B.symbol()->IsUsedInRegularObj)
     return false;
 
   if (auto *D = dyn_cast<DefinedRegular>(&B)) {
     // Always include absolute symbols.
-    if (!D->Section)
+    SectionBase *Sec = D->Section;
+    if (!Sec)
       return true;
+    if (auto *IS = dyn_cast<InputSectionBase>(Sec)) {
+      Sec = IS->Repl;
+      IS = cast<InputSectionBase>(Sec);
       // Exclude symbols pointing to garbage-collected sections.
-    if (!D->Section->Live)
+      if (!IS->Live)
         return false;
-    if (auto *S = dyn_cast<MergeInputSection>(D->Section))
+    }
+    if (auto *S = dyn_cast<MergeInputSection>(Sec))
       if (!S->getSectionPiece(D->Value)->Live)
         return false;
   }
   return true;
 }
 
 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   if (!In<ELFT>::SymTab)
     return;
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
     for (SymbolBody *B : F->getLocalSymbols()) {
       if (!B->IsLocal)
         fatal(toString(F) +
               ": broken object: getLocalSymbols returns a non-local symbol");
       auto *DR = dyn_cast<DefinedRegular>(B);
 
       // No reason to keep local undefined symbol in symtab.
       if (!DR)
         continue;
       if (!includeInSymtab<ELFT>(*B))
         continue;
 
-      InputSectionBase *Sec = DR->Section;
+      SectionBase *Sec = DR->Section;
       if (!shouldKeepInSymtab<ELFT>(Sec, B->getName(), *B))
         continue;
       In<ELFT>::SymTab->addSymbol(B);
     }
   }
 }
 
 template <class ELFT> void Writer<ELFT>::addSectionSymbols() {
void PhdrEntry::add(OutputSection *Sec) {
   if (!First)
     First = Sec;
   p_align = std::max(p_align, Sec->Alignment);
   if (p_type == PT_LOAD)
     Sec->FirstInPtLoad = First;
 }
 
 template <class ELFT>
-static DefinedSynthetic *addOptionalSynthetic(StringRef Name,
-                                              OutputSection *Sec, uint64_t Val,
-                                              uint8_t StOther = STV_HIDDEN) {
-  if (SymbolBody *S = Symtab<ELFT>::X->find(Name))
-    if (!S->isInCurrentDSO())
-      return cast<DefinedSynthetic>(
-          Symtab<ELFT>::X->addSynthetic(Name, Sec, Val, StOther)->body());
-  return nullptr;
-}
-
-template <class ELFT>
-static Symbol *addRegular(StringRef Name, InputSectionBase *Sec,
-                          uint64_t Value) {
+static Symbol *addRegular(StringRef Name, SectionBase *Sec, uint64_t Value,
+                          uint8_t StOther = STV_HIDDEN,
+                          uint8_t Binding = STB_WEAK) {
   // The linker generated symbols are added as STB_WEAK to allow user defined
   // ones to override them.
-  return Symtab<ELFT>::X->addRegular(Name, STV_HIDDEN, STT_NOTYPE, Value,
-                                     /*Size=*/0, STB_WEAK, Sec,
+  return Symtab<ELFT>::X->addRegular(Name, StOther, STT_NOTYPE, Value,
+                                     /*Size=*/0, Binding, Sec,
                                      /*File=*/nullptr);
 }
 
 template <class ELFT>
-static Symbol *addOptionalRegular(StringRef Name, InputSectionBase *IS,
-                                  uint64_t Value) {
+static DefinedRegular *
+addOptionalRegular(StringRef Name, SectionBase *Sec, uint64_t Val,
+                   uint8_t StOther = STV_HIDDEN, uint8_t Binding = STB_GLOBAL) {
   SymbolBody *S = Symtab<ELFT>::X->find(Name);
   if (!S)
     return nullptr;
   if (S->isInCurrentDSO())
-    return S->symbol();
-  return addRegular<ELFT>(Name, IS, Value);
+    return nullptr;
+  return cast<DefinedRegular>(
+      addRegular<ELFT>(Name, Sec, Val, StOther, Binding)->body());
 }
 
 // The beginning and the ending of .rel[a].plt section are marked
 // with __rel[a]_iplt_{start,end} symbols if it is a statically linked
 // executable. The runtime needs these symbols in order to resolve
 // all IRELATIVE relocs on startup. For dynamic executables, we don't
 // need these symbols, since IRELATIVE relocs are resolved through GOT
 // and PLT. For details, see http://www.airs.com/blog/archives/403.
 template <class ELFT> void Writer<ELFT>::addRelIpltSymbols() {
   if (In<ELFT>::DynSymTab)
     return;
   StringRef S = Config->isRela() ? "__rela_iplt_start" : "__rel_iplt_start";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, 0);
+  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, 0, STV_HIDDEN, STB_WEAK);
 
   S = Config->isRela() ? "__rela_iplt_end" : "__rel_iplt_end";
-  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, -1);
+  addOptionalRegular<ELFT>(S, In<ELFT>::RelaIplt, -1, STV_HIDDEN, STB_WEAK);
 }
 
 // The linker is expected to define some symbols depending on
 // the linking result. This function defines such symbols.
 template <class ELFT> void Writer<ELFT>::addReservedSymbols() {
   if (Config->EMachine == EM_MIPS) {
     // Define _gp for MIPS. st_value of _gp symbol will be updated by Writer
     // so that it points to an absolute address which by default is relative
if (!In<ELFT>::DynSymTab &&
       (Config->EMachine != EM_MIPS && Config->EMachine != EM_ARM))
     Symtab<ELFT>::X->addIgnored("__tls_get_addr");
 
   // If linker script do layout we do not need to create any standart symbols.
   if (ScriptConfig->HasSections)
     return;
 
   // __ehdr_start is the location of ELF file headers.
-  addOptionalSynthetic<ELFT>("__ehdr_start", Out::ElfHeader, 0);
+  addOptionalRegular<ELFT>("__ehdr_start", Out::ElfHeader, 0, STV_HIDDEN);
 
-  auto Define = [](StringRef S, DefinedSynthetic *&Sym1,
-                   DefinedSynthetic *&Sym2) {
-    Sym1 = addOptionalSynthetic<ELFT>(S, nullptr, 0, STV_DEFAULT);
+  auto Define = [](StringRef S, DefinedRegular *&Sym1, DefinedRegular *&Sym2) {
+    Sym1 = addOptionalRegular<ELFT>(S, Out::ElfHeader, 0, STV_DEFAULT);
     assert(S.startswith("_"));
     S = S.substr(1);
-    Sym2 = addOptionalSynthetic<ELFT>(S, nullptr, 0, STV_DEFAULT);
+    Sym2 = addOptionalRegular<ELFT>(S, Out::ElfHeader, 0, STV_DEFAULT);
   };
 
   Define("_end", ElfSym::End, ElfSym::End2);
   Define("_etext", ElfSym::Etext, ElfSym::Etext2);
   Define("_edata", ElfSym::Edata, ElfSym::Edata2);
 }
 
 // Sort input sections by section name suffixes for
static void sortBySymbolsOrder(ArrayRef<OutputSection *> OutputSections) {
   // appear in the symbol ordering file have the lowest priority 0.
   // All explicitly mentioned symbols have negative (higher) priorities.
   DenseMap<StringRef, int> SymbolOrder;
   int Priority = -Config->SymbolOrderingFile.size();
   for (StringRef S : Config->SymbolOrderingFile)
     SymbolOrder.insert({S, Priority++});
 
   // Build a map from sections to their priorities.
-  DenseMap<InputSectionBase *, int> SectionOrder;
+  DenseMap<SectionBase *, int> SectionOrder;
   for (elf::ObjectFile<ELFT> *File : Symtab<ELFT>::X->getObjectFiles()) {
     for (SymbolBody *Body : File->getSymbols()) {
       auto *D = dyn_cast<DefinedRegular>(Body);
       if (!D || !D->Section)
         continue;
       int &Priority = SectionOrder[D->Section];
       Priority = std::min(Priority, SymbolOrder.lookup(D->getName()));
     }

 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end
 // symbols for a few sections. This function defines them.
 template <class ELFT> void Writer<ELFT>::addStartEndSymbols() {
   auto Define = [&](StringRef Start, StringRef End, OutputSection *OS) {
     // These symbols resolve to the image base if the section does not exist.
     // A special value -1 indicates end of the section.
-    addOptionalSynthetic<ELFT>(Start, OS, 0);
-    addOptionalSynthetic<ELFT>(End, OS, OS ? -1 : 0);
+    if (!OS && Config->pic())
+      OS = Out::ElfHeader;
+    addOptionalRegular<ELFT>(Start, OS, 0);
+    addOptionalRegular<ELFT>(End, OS, OS ? -1 : 0);
   };
 
   Define("__preinit_array_start", "__preinit_array_end", Out::PreinitArray);
   Define("__init_array_start", "__init_array_end", Out::InitArray);
   Define("__fini_array_start", "__fini_array_end", Out::FiniArray);
 
   if (OutputSection *Sec = findSection(".ARM.exidx"))
     Define("__exidx_start", "__exidx_end", Sec);
 }
 
 // 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(OutputSection *Sec) {
   StringRef S = Sec->Name;
   if (!isValidCIdentifier(S))
     return;
-  addOptionalSynthetic<ELFT>(Saver.save("__start_" + S), Sec, 0, STV_DEFAULT);
-  addOptionalSynthetic<ELFT>(Saver.save("__stop_" + S), Sec, -1, STV_DEFAULT);
+  addOptionalRegular<ELFT>(Saver.save("__start_" + S), Sec, 0, STV_DEFAULT);
+  addOptionalRegular<ELFT>(Saver.save("__stop_" + S), Sec, -1, STV_DEFAULT);
 }
 
 template <class ELFT> OutputSection *Writer<ELFT>::findSection(StringRef Name) {
   for (OutputSection *Sec : OutputSections)
     if (Sec->Name == Name)
       return Sec;
   return nullptr;
 }
if (Config->Relocatable)
     return ET_REL;
   return ET_EXEC;
 }
 
 // This function is called after we have assigned address and size
 // to each section. This function fixes some predefined
 // symbol values that depend on section address and size.
 template <class ELFT> void Writer<ELFT>::fixPredefinedSymbols() {
-  auto Set = [](DefinedSynthetic *S1, DefinedSynthetic *S2, OutputSection *Sec,
+  auto Set = [](DefinedRegular *S1, DefinedRegular *S2, OutputSection *Sec,
                 uint64_t Value) {
     if (S1) {
       S1->Section = Sec;
       S1->Value = Value;
     }
     if (S2) {
       S2->Section = Sec;
       S2->Value = Value;