[ELF] - Add support for access to most of synthetic sections from linkerscript.

[grimar]

Summary

This is important for FreeBSD EFI bootloaders one of which has next script:

  .sdata        : {
    *(.got.plt .got)
...
  }

So it wants to place got.plt and got into single section of name .sdata.
That was not supported before as there was no way to get access to
synthetic sections from script.

To do that we need to add them early to Symtab<ELFT>::X->Sections.
That involves next problems:

1. Not all sections are required in output finally. For example we do not need

to emit got content when it has no entries. Patch solves that in next way:
after script do its job of layouting, removeUnusedSynthetics() is called.
Main intention to check the condition for each synthetic and remove it from output
if it is not needed.

2. Adding sections early involves possible change in ordering. That is why this patch

does not do support for all sections at ones. Otherwise too many tests fill fail (up to 150).
It still breaks order for .eh_frame, that is why few relative testcases were fixes.
I believe that is not a problem.

If we land this - we might be able to add all rest sections in next patches
and get rid off addPredefinedSections() fully I think.

[evgeny777]

ELF/Writer.cpp

230

This looks better

auto add = [](InputSection<ELFT> *IS) {
  Symtab<ELFT>::X->Sections.push_back(IS);
  return IS;
};

255

In<ELFT>::Interp = add(createInterpSection<ELFT>());

724

Why are you checking IS for nullptr?

884

Why are you checking for null?

890

Looks like you're removing all sections starting from unused synthetic till the end of the input section array. May be you actually wanted to use std::remove() ?

[grimar]

• Addressed review comments.

ELF/Writer.cpp

230

Unfortunately this will not work. You can not assign base class pointer to derived.
I applied the idea of your suggestion though.

724

Forgot to remove after experiments, thanks.

884

Because Symtab<ELFT>::X->Sections contains all sections, not only synthetic.
And that works like optimization.

I am iterating from the end to start and stop doing that when met non-synthetic section,
which will be null after cast.

890

It is a mistake definetely. Wanted to use std::erase(Iterator) form, like below.

[grimar]

• Fixed compilation error under FreeBSD.

[ruiu]

ELF/SyntheticSections.h

35

isPresent sound a bit odd to me, because as soon as you instantiate objects, they are present. How about empty?

ELF/Writer.cpp

230

It seems unnecessarily complicated. I'd just remove this function and inline it.

255

For example, I'd write

In<ELFT>::Interp = createInterpSection<EFLT>();
Symtab<ELFT>::X->Sections.push_back(In<ELFT>::Interp);

878

removeUnusedSyntheticSections because we have other synthetic things such as synthetic symbols.

881–882

Use llvm::reverse.

[grimar]

• Addressed review comments.

[grimar]

ELF/SyntheticSections.h

35

Done.

ELF/Writer.cpp

230

I did that though I find this a bit bulky code. I think we may want to refactor it in this way separatelly.

878

Done.

881–882

Done.

[ruiu]

ELF/SyntheticSections.h

35

Well, empty should return true if it is empty. Your functions return true if it is not empty.

[grimar]

• Addressed review comments.
• Removed 2 excessive checks.

[ruiu]

ELF/SyntheticSections.cpp

1591–1592

I don't understand these conditions. Is this the same as the code below?

if (!In<ELFT>::Verdef)
  return true;
return In<ELFT>::VerNeed->empty();

[grimar]

ELF/SyntheticSections.cpp

1591–1592

It is the same as:

template <class ELFT> bool VersionTableSection<ELFT>::empty() const {
  return !In<ELFT>::VerDef && In<ELFT>::VerNeed->empty();
}

[ruiu]

ELF/SyntheticSections.cpp

1591–1592

So, you meant VersionTable is empty if

• we have a VerDef section,
• and VerNeed is empty.

But why?

[grimar]

ELF/SyntheticSections.cpp

1591–1592

Mmm, no, it is empty if

• we do not have Verdef
• and VerNeed is empty.

[ruiu]

ELF/SyntheticSections.cpp

1591–1592

Then

if (In<ELFT>::VerDef == nullptr)
  return true;
return In<ELFT>::VerNeed->empty();

This is the same code as I wrote in the first comment.

[grimar]

ELF/SyntheticSections.cpp

1591–1592

No, because your code will return empty if we do not have Verdef but have entries in VerNeed

[ruiu]

ELF/SyntheticSections.cpp

1591–1592

I don't know what you are doing here is right, I need to take a look at the original code. Anyways, can you rewrite this code so that it is easy to understand?

[grimar]

ELF/SyntheticSections.cpp

1591–1592

Sure. Just what would you prefer:

template <class ELFT> bool VersionTableSection<ELFT>::empty() const {
  if (!In<ELFT>::VerDef)
    return In<ELFT>::VerNeed->empty();
  return false;
}

or

template <class ELFT> bool VersionTableSection<ELFT>::empty() const {
  return !In<ELFT>::VerDef && In<ELFT>::VerNeed->empty();
}

[grimar]

ELF/SyntheticSections.cpp

1591–1592

I think I know what confused you.
You wrote:

if (!In<ELFT>::Verdef)
  return true;

but this is not the same as

if (!In<ELFT>::Verdef->empty())
  return true;

[ruiu]

ELF/SyntheticSections.cpp

1591–1592

This corresponds to https://github.com/llvm-mirror/lld/blob/5313f87928d212b6cd216cb4c7c22448d335e33e/ELF/Writer.cpp#L991, right?

[grimar]

ELF/SyntheticSections.cpp

1591–1592

Yes, sure. That where I took the condition from initially.

[ruiu]

LGTM

ELF/SyntheticSections.cpp

1591–1592

OK, then this is consistent. Please replace it with the one line code.

ELF/SyntheticSections.h

SyntheticSection(uintX_t Flags, uint32_t Type, uintX_t Addralign,
                            InputSectionData::Synthetic) {
     this->Live = true;
   }
 
   virtual ~SyntheticSection() = default;
   virtual void writeTo(uint8_t *Buf) = 0;
   virtual size_t getSize() const = 0;
   virtual void finalize() {}
+  virtual bool isPresent() const { return true; }
 
   uintX_t getVA() const {
     return this->OutSec ? this->OutSec->Addr + this->OutSecOff : 0;
   }
 
   static bool classof(const InputSectionData *D) {
     return D->kind() == InputSectionData::Synthetic;
   }
 };
 
 template <class ELFT> class GotSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void finalize() override;
+  bool isPresent() const override;
+
   void addEntry(SymbolBody &Sym);
   bool addDynTlsEntry(SymbolBody &Sym);
   bool addTlsIndex();
   bool empty() const { return Entries.empty(); }
   uintX_t getGlobalDynAddr(const SymbolBody &B) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
 
   uintX_t getTlsIndexVA() { return this->getVA() + TlsIndexOff; }

 class MipsGotSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   MipsGotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void finalize() override;
+  bool isPresent() const override;
   void addEntry(SymbolBody &Sym, uintX_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
   bool addTlsIndex();
   bool empty() const { return PageEntriesNum == 0 && TlsEntries.empty(); }
   uintX_t getPageEntryOffset(uintX_t Addr);
   uintX_t getBodyEntryOffset(const SymbolBody &B, uintX_t Addend) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
 

 
 template <class ELFT>
 class GotPltSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   GotPltSection();
   void addEntry(SymbolBody &Sym);
-  bool empty() const;
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
+  bool isPresent() const override { return !Entries.empty(); }
 
 private:
   std::vector<const SymbolBody *> Entries;
 };
 
 template <class ELFT>
 class StringTableSection final : public SyntheticSection<ELFT> {
 public:
class RelocationSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   RelocationSection(StringRef Name, bool Sort);
   void addReloc(const DynamicReloc<ELFT> &Reloc);
   unsigned getRelocOffset();
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
+  bool isPresent() const override { return !Relocs.empty(); }
   size_t getSize() const override { return Relocs.size() * this->Entsize; }
-  bool hasRelocs() const { return !Relocs.empty(); }
   size_t getRelativeRelocCount() const { return NumRelativeRelocs; }
 
 private:
   bool Sort;
   size_t NumRelativeRelocs = 0;
   std::vector<DynamicReloc<ELFT>> Relocs;
 };
 

 class EhFrameHeader final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;
 
 public:
   EhFrameHeader();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   void addFde(uint32_t Pc, uint32_t FdeVA);
+  bool isPresent() const override;
 
 private:
   struct FdeData {
     uint32_t Pc;
     uint32_t FdeVA;
   };
 
   std::vector<FdeData> Fdes;

 class VersionTableSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::Versym Elf_Versym;
 
 public:
   VersionTableSection();
   void finalize() override;
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
+  bool isPresent() const override;
 };
 
 // The .gnu.version_r section defines the version identifiers used by
 // .gnu.version. It contains a linked list of Elf_Verneed data structures. Each
 // Elf_Verneed specifies the version requirements for a single DSO, and contains
 // a reference to a linked list of Elf_Vernaux data structures which define the
 // mapping from version identifiers to version names.
 template <class ELFT>

 
 public:
   VersionNeedSection();
   void addSymbol(SharedSymbol<ELFT> *SS);
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   size_t getNeedNum() const { return Needed.size(); }
+  bool isPresent() const override;
 };
 
 // .MIPS.abiflags section.
 template <class ELFT>
 class MipsAbiFlagsSection final : public SyntheticSection<ELFT> {
   typedef llvm::object::Elf_Mips_ABIFlags<ELFT> Elf_Mips_ABIFlags;
 
 public:

ELF/SyntheticSections.cpp

 GotSection<ELFT>::getGlobalDynOffset(const SymbolBody &B) const {
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
 template <class ELFT> void GotSection<ELFT>::finalize() {
   Size = Entries.size() * sizeof(uintX_t);
 }
 
+template <class ELFT> bool GotSection<ELFT>::isPresent() const {
+  // If we have a relocation that is relative to GOT (such as GOTOFFREL),
+  // we need to emit a GOT even if it's empty.
+  return Config->EMachine != EM_MIPS && (!empty() || HasGotOffRel);
+}
+
 template <class ELFT> void GotSection<ELFT>::writeTo(uint8_t *Buf) {
   for (const SymbolBody *B : Entries) {
     uint8_t *Entry = Buf;
     Buf += sizeof(uintX_t);
     if (!B)
       continue;
     if (B->isPreemptible())
       continue; // The dynamic linker will take care of it.
for (const OutputSectionBase *OutSec : OutSections) {
     // Add 0x8000 to the section's size because the page address stored
     // in the GOT entry is calculated as (value + 0x8000) & ~0xffff.
     PageEntriesNum += (OutSec->Size + 0x8000 + 0xfffe) / 0xffff;
   }
   EntriesNum += getLocalEntriesNum() + GlobalEntries.size();
   Size = EntriesNum * sizeof(uintX_t);
 }
 
+template <class ELFT> bool MipsGotSection<ELFT>::isPresent() const {
+  // We add the .got section to the result for dynamic MIPS target because
+  // its address and properties are mentioned in the .dynamic section.
+  return Config->EMachine == EM_MIPS && !Config->Relocatable;
+}
+
 template <class ELFT>
 static void writeUint(uint8_t *Buf, typename ELFT::uint Val) {
   typedef typename ELFT::uint uintX_t;
   write<uintX_t, ELFT::TargetEndianness, sizeof(uintX_t)>(Buf, Val);
 }
 
 template <class ELFT> void MipsGotSection<ELFT>::writeTo(uint8_t *Buf) {
   // Set the MSB of the second GOT slot. This is not required by any
GotPltSection<ELFT>::GotPltSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                              Target->GotPltEntrySize, ".got.plt") {}
 
 template <class ELFT> void GotPltSection<ELFT>::addEntry(SymbolBody &Sym) {
   Sym.GotPltIndex = Target->GotPltHeaderEntriesNum + Entries.size();
   Entries.push_back(&Sym);
 }
 
-template <class ELFT> bool GotPltSection<ELFT>::empty() const {
-  return Entries.empty();
-}
-
 template <class ELFT> size_t GotPltSection<ELFT>::getSize() const {
   return (Target->GotPltHeaderEntriesNum + Entries.size()) *
          Target->GotPltEntrySize;
 }
 
 template <class ELFT> void GotPltSection<ELFT>::writeTo(uint8_t *Buf) {
   Target->writeGotPltHeader(Buf);
   Buf += Target->GotPltHeaderEntriesNum * Target->GotPltEntrySize;

 
 // Add remaining entries to complete .dynamic contents.
 template <class ELFT> void DynamicSection<ELFT>::finalize() {
   if (this->Size)
     return; // Already finalized.
 
   this->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
 
-  if (In<ELFT>::RelaDyn->hasRelocs()) {
+  if (In<ELFT>::RelaDyn->isPresent()) {
     bool IsRela = Config->Rela;
     add({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
     add({IsRela ? DT_RELASZ : DT_RELSZ, In<ELFT>::RelaDyn->getSize()});
     add({IsRela ? DT_RELAENT : DT_RELENT,
          uintX_t(IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel))});
 
     // MIPS dynamic loader does not support RELCOUNT tag.
     // The problem is in the tight relation between dynamic
     // relocations and GOT. So do not emit this tag on MIPS.
     if (Config->EMachine != EM_MIPS) {
       size_t NumRelativeRels = In<ELFT>::RelaDyn->getRelativeRelocCount();
       if (Config->ZCombreloc && NumRelativeRels)
         add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
     }
   }
-  if (In<ELFT>::RelaPlt->hasRelocs()) {
+  if (In<ELFT>::RelaPlt->isPresent()) {
     add({DT_JMPREL, In<ELFT>::RelaPlt});
     add({DT_PLTRELSZ, In<ELFT>::RelaPlt->getSize()});
     add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
          In<ELFT>::GotPlt});
     add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
   }
 
   add({DT_SYMTAB, In<ELFT>::DynSymTab});
template <class ELFT> size_t EhFrameHeader<ELFT>::getSize() const {
   return 12 + Out<ELFT>::EhFrame->NumFdes * 8;
 }
 
 template <class ELFT>
 void EhFrameHeader<ELFT>::addFde(uint32_t Pc, uint32_t FdeVA) {
   Fdes.push_back({Pc, FdeVA});
 }
 
+template <class ELFT> bool EhFrameHeader<ELFT>::isPresent() const {
+  return !Out<ELFT>::EhFrame->empty();
+}
+
 template <class ELFT>
 VersionDefinitionSection<ELFT>::VersionDefinitionSection()
     : SyntheticSection<ELFT>(SHF_ALLOC, SHT_GNU_verdef, sizeof(uint32_t),
                              ".gnu.version_d") {}
 
 static StringRef getFileDefName() {
   if (!Config->SoName.empty())
     return Config->SoName;

 template <class ELFT> void VersionTableSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *OutVersym = reinterpret_cast<Elf_Versym *>(Buf) + 1;
   for (const SymbolTableEntry &S : In<ELFT>::DynSymTab->getSymbols()) {
     OutVersym->vs_index = S.Symbol->symbol()->VersionId;
     ++OutVersym;
   }
 }
 
+template <class ELFT> bool VersionTableSection<ELFT>::isPresent() const {
+  bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
+  return In<ELFT>::VerDef || HasVerNeed;
+}
+
 template <class ELFT>
 VersionNeedSection<ELFT>::VersionNeedSection()
     : SyntheticSection<ELFT>(SHF_ALLOC, SHT_GNU_verneed, sizeof(uint32_t),
                              ".gnu.version_r") {
   // Identifiers in verneed section start at 2 because 0 and 1 are reserved
   // for VER_NDX_LOCAL and VER_NDX_GLOBAL.
   // First identifiers are reserved by verdef section if it exist.
   NextIndex = getVerDefNum() + 1;

 
 template <class ELFT> size_t VersionNeedSection<ELFT>::getSize() const {
   unsigned Size = Needed.size() * sizeof(Elf_Verneed);
   for (const std::pair<SharedFile<ELFT> *, size_t> &P : Needed)
     Size += P.first->VerdefMap.size() * sizeof(Elf_Vernaux);
   return Size;
 }
 
+template <class ELFT> bool VersionNeedSection<ELFT>::isPresent() const {
+  return getNeedNum() != 0;
+}
+
 template <class ELFT>
 MipsRldMapSection<ELFT>::MipsRldMapSection()
     : SyntheticSection<ELFT>(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                              sizeof(typename ELFT::uint), ".rld_map") {}
 
 template <class ELFT> void MipsRldMapSection<ELFT>::writeTo(uint8_t *Buf) {
   // Apply filler from linker script.
   uint64_t Filler = Script<ELFT>::X->getFiller(this->Name);

ELF/Writer.cpp

private:
   void copyLocalSymbols();
   void addReservedSymbols();
   void addInputSec(InputSectionBase<ELFT> *S);
   void createSections();
   void forEachRelSec(std::function<void(InputSectionBase<ELFT> &)> Fn);
   void sortSections();
   void finalizeSections();
   void addPredefinedSections();
-  bool needsGot();
 
   std::vector<Phdr> createPhdrs();
   void assignAddresses();
   void assignFileOffsets();
   void assignFileOffsetsBinary();
   void setPhdrs();
   void fixHeaders();
   void fixSectionAlignments();
template <class ELFT> void Writer<ELFT>::run() {
 
   // Flush the output streams and exit immediately. A full shutdown
   // is a good test that we are keeping track of all allocated memory,
   // but actually freeing it is a waste of time in a regular linker run.
   if (Config->ExitEarly)
     exitLld(0);
 }
 
+template <class ELFT, class Sec> static Sec *add(Sec *S) {
+  Symtab<ELFT>::X->Sections.push_back(S);
+  return S;
+};
+
 // Initialize Out<ELFT> members.
 template <class ELFT> void Writer<ELFT>::createSyntheticSections() {
   // Initialize all pointers with NULL. This is needed because
   // you can call lld::elf::main more than once as a library.
   memset(&Out<ELFT>::First, 0, sizeof(Out<ELFT>));
 
   // Create singleton output sections.
   Out<ELFT>::Bss =
       make<OutputSection<ELFT>>(".bss", SHT_NOBITS, SHF_ALLOC | SHF_WRITE);
   In<ELFT>::DynStrTab = make<StringTableSection<ELFT>>(".dynstr", true);
   In<ELFT>::Dynamic = make<DynamicSection<ELFT>>();
   Out<ELFT>::EhFrame = make<EhOutputSection<ELFT>>();
   In<ELFT>::Plt = make<PltSection<ELFT>>();
   In<ELFT>::RelaDyn = make<RelocationSection<ELFT>>(
       Config->Rela ? ".rela.dyn" : ".rel.dyn", Config->ZCombreloc);
   In<ELFT>::ShStrTab = make<StringTableSection<ELFT>>(".shstrtab", false);
-  In<ELFT>::VerSym = make<VersionTableSection<ELFT>>();
-  In<ELFT>::VerNeed = make<VersionNeedSection<ELFT>>();
 
   Out<ELFT>::ElfHeader = make<OutputSectionBase>("", 0, SHF_ALLOC);
   Out<ELFT>::ElfHeader->Size = sizeof(Elf_Ehdr);
   Out<ELFT>::ProgramHeaders = make<OutputSectionBase>("", 0, SHF_ALLOC);
   Out<ELFT>::ProgramHeaders->updateAlignment(sizeof(uintX_t));
 
-  if (needsInterpSection<ELFT>()) {
-    In<ELFT>::Interp = createInterpSection<ELFT>();
-    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::Interp);
-  } else {
+  if (needsInterpSection<ELFT>())
+    In<ELFT>::Interp = add<ELFT>(createInterpSection<ELFT>());
+  else
     In<ELFT>::Interp = nullptr;
-  }
-
-  if (!Symtab<ELFT>::X->getSharedFiles().empty() || Config->Pic) {
-    In<ELFT>::DynSymTab = make<SymbolTableSection<ELFT>>(*In<ELFT>::DynStrTab);
-  }
 
   if (Config->EhFrameHdr)
     In<ELFT>::EhFrameHdr = make<EhFrameHeader<ELFT>>();
 
-  if (Config->GnuHash)
-    In<ELFT>::GnuHashTab = make<GnuHashTableSection<ELFT>>();
-  if (Config->SysvHash)
-    In<ELFT>::HashTab = make<HashTableSection<ELFT>>();
   if (Config->GdbIndex)
     In<ELFT>::GdbIndex = make<GdbIndexSection<ELFT>>();
 
   In<ELFT>::RelaPlt = make<RelocationSection<ELFT>>(
       Config->Rela ? ".rela.plt" : ".rel.plt", false /*Sort*/);
   if (Config->Strip != StripPolicy::All) {
     In<ELFT>::StrTab = make<StringTableSection<ELFT>>(".strtab", false);
     In<ELFT>::SymTab = make<SymbolTableSection<ELFT>>(*In<ELFT>::StrTab);
   }
 
-  if (!Config->VersionDefinitions.empty())
-    In<ELFT>::VerDef = make<VersionDefinitionSection<ELFT>>();
-
   // Initialize linker generated sections
   if (!Config->Relocatable)
     Symtab<ELFT>::X->Sections.push_back(createCommentSection<ELFT>());
 
-  if (Config->BuildId != BuildIdKind::None) {
-    In<ELFT>::BuildId = make<BuildIdSection<ELFT>>();
-    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::BuildId);
-  }
+  if (Config->BuildId != BuildIdKind::None)
+    In<ELFT>::BuildId = add<ELFT>(make<BuildIdSection<ELFT>>());
 
   InputSection<ELFT> *Common = createCommonSection<ELFT>();
-  if (!Common->Data.empty()) {
-    In<ELFT>::Common = Common;
-    Symtab<ELFT>::X->Sections.push_back(Common);
-  }
+  if (!Common->Data.empty())
+    In<ELFT>::Common = add<ELFT>(Common);
 
   // Add MIPS-specific sections.
+  bool HasDynSymTab = !Symtab<ELFT>::X->getSharedFiles().empty() || Config->Pic;
   if (Config->EMachine == EM_MIPS) {
-    if (!Config->Shared && In<ELFT>::DynSymTab) {
-      In<ELFT>::MipsRldMap = make<MipsRldMapSection<ELFT>>();
-      Symtab<ELFT>::X->Sections.push_back(In<ELFT>::MipsRldMap);
-    }
+    if (!Config->Shared && HasDynSymTab)
+      In<ELFT>::MipsRldMap = add<ELFT>(make<MipsRldMapSection<ELFT>>());
     if (auto *Sec = MipsAbiFlagsSection<ELFT>::create())
       Symtab<ELFT>::X->Sections.push_back(Sec);
     if (auto *Sec = MipsOptionsSection<ELFT>::create())
       Symtab<ELFT>::X->Sections.push_back(Sec);
     if (auto *Sec = MipsReginfoSection<ELFT>::create())
       Symtab<ELFT>::X->Sections.push_back(Sec);
   }
 
+  if (HasDynSymTab) {
+    In<ELFT>::DynSymTab =
+        add<ELFT>(make<SymbolTableSection<ELFT>>(*In<ELFT>::DynStrTab));
+
+    In<ELFT>::VerSym = add<ELFT>(make<VersionTableSection<ELFT>>());
+    if (!Config->VersionDefinitions.empty())
+      In<ELFT>::VerDef = add<ELFT>(make<VersionDefinitionSection<ELFT>>());
+    In<ELFT>::VerNeed = add<ELFT>(make<VersionNeedSection<ELFT>>());
+
+    if (Config->GnuHash)
+      In<ELFT>::GnuHashTab = add<ELFT>(make<GnuHashTableSection<ELFT>>());
+    if (Config->SysvHash)
+      In<ELFT>::HashTab = add<ELFT>(make<HashTableSection<ELFT>>());
+
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::Dynamic);
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::DynStrTab);
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::RelaDyn);
+  }
+
   // Add .got. MIPS' .got is so different from the other archs,
   // it has its own class.
   if (Config->EMachine == EM_MIPS)
-    In<ELFT>::MipsGot = make<MipsGotSection<ELFT>>();
+    In<ELFT>::MipsGot = add<ELFT>(make<MipsGotSection<ELFT>>());
   else
-    In<ELFT>::Got = make<GotSection<ELFT>>();
+    In<ELFT>::Got = add<ELFT>(make<GotSection<ELFT>>());
 
-  In<ELFT>::GotPlt = make<GotPltSection<ELFT>>();
+  In<ELFT>::GotPlt = add<ELFT>(make<GotPltSection<ELFT>>());
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
if (OutputSection<ELFT> *Sec = dyn_cast<OutputSection<ELFT>>(Base))
         return It == SectionsOrder.end() ? UINT32_MAX : It->second;
       });
 }
 
 template <class ELFT>
 void Writer<ELFT>::forEachRelSec(
     std::function<void(InputSectionBase<ELFT> &)> Fn) {
   for (InputSectionBase<ELFT> *IS : Symtab<ELFT>::X->Sections) {
     if (!IS->Live)
       continue;
     // Scan all relocations. Each relocation goes through a series
     // of tests to determine if it needs special treatment, such as
     // creating GOT, PLT, copy relocations, etc.
     // Note that relocations for non-alloc sections are directly
     // processed by InputSection::relocateNonAlloc.
     if (!(IS->Flags & SHF_ALLOC))
       continue;
finalizeSynthetic(const std::vector<SyntheticSection<ELFT> *> &Sections) {
   for (SyntheticSection<ELFT> *SS : Sections)
     if (SS && SS->OutSec) {
       SS->finalize();
       SS->OutSec->Size = 0;
       SS->OutSec->assignOffsets();
     }
 }
 
+// We need to add synthetic sections early in createSyntheticSections() to make
+// them visible from linkescript side. But not all sections are always required
+// to be in output. For example we don't need dynamic section content sometimes.
+// This function filters out such unused sections from output.
+template <class ELFT>
+static void removeUnusedSynthetics(std::vector<OutputSectionBase *> &V) {
+  // Synthetic sections are placed after all regular ones. We iterate over them
+  // all and exit at first non-synthetic.
+  for (auto I = Symtab<ELFT>::X->Sections.rbegin();
+       I != Symtab<ELFT>::X->Sections.rend(); ++I) {
+    SyntheticSection<ELFT> *SS = dyn_cast<SyntheticSection<ELFT>>(*I);
+    if (!SS)
+      return;
+    if (SS->isPresent() || !SS->OutSec)
+      continue;
+
+    OutputSection<ELFT> *OutSec = cast<OutputSection<ELFT>>(SS->OutSec);
+    OutSec->Sections.erase(
+        std::find(OutSec->Sections.begin(), OutSec->Sections.end(), SS));
+    // If there is no other sections in output section, remove it from output.
+    if (OutSec->Sections.empty())
+      V.erase(std::find(V.begin(), V.end(), OutSec));
+  }
+}
+
 // Create output section objects and add them to OutputSections.
 template <class ELFT> void Writer<ELFT>::finalizeSections() {
   Out<ELFT>::DebugInfo = findSection(".debug_info");
   Out<ELFT>::PreinitArray = findSection(".preinit_array");
   Out<ELFT>::InitArray = findSection(".init_array");
   Out<ELFT>::FiniArray = findSection(".fini_array");
 
   // The linker needs to define SECNAME_start, SECNAME_end and SECNAME_stop
template <class ELFT> void Writer<ELFT>::finalizeSections() {
 
   // Do not proceed if there was an undefined symbol.
   if (HasError)
     return;
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();
+  removeUnusedSynthetics<ELFT>(OutputSections);
 
   sortSections();
 
   unsigned I = 1;
   for (OutputSectionBase *Sec : OutputSections) {
     Sec->SectionIndex = I++;
     Sec->ShName = In<ELFT>::ShStrTab->addString(Sec->getName());
   }
finalizeSynthetic<ELFT>(
       {In<ELFT>::DynSymTab, In<ELFT>::GnuHashTab, In<ELFT>::HashTab,
        In<ELFT>::SymTab, In<ELFT>::ShStrTab, In<ELFT>::StrTab, In<ELFT>::VerDef,
        In<ELFT>::DynStrTab, In<ELFT>::GdbIndex, In<ELFT>::Got,
        In<ELFT>::MipsGot, In<ELFT>::GotPlt, In<ELFT>::RelaDyn,
        In<ELFT>::RelaPlt, In<ELFT>::Plt, In<ELFT>::EhFrameHdr, In<ELFT>::VerSym,
        In<ELFT>::VerNeed, In<ELFT>::Dynamic});
 }
 
-template <class ELFT> bool Writer<ELFT>::needsGot() {
-  // 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)
-    return !Config->Relocatable;
-
-  if (!In<ELFT>::Got->empty())
-    return true;
-
-  // If we have a relocation that is relative to GOT (such as GOTOFFREL),
-  // we need to emit a GOT even if it's empty.
-  return In<ELFT>::Got->HasGotOffRel;
-}
-
 // This function add Out<ELFT>::* sections to OutputSections.
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
   auto Add = [&](OutputSectionBase *OS) {
     if (OS)
       OutputSections.push_back(OS);
   };
 
   // This order is not the same as the final output order
   // because we sort the sections using their attributes below.
   if (In<ELFT>::GdbIndex && Out<ELFT>::DebugInfo)
     addInputSec(In<ELFT>::GdbIndex);
   addInputSec(In<ELFT>::SymTab);
   addInputSec(In<ELFT>::ShStrTab);
   addInputSec(In<ELFT>::StrTab);
-  if (In<ELFT>::DynSymTab) {
-    addInputSec(In<ELFT>::DynSymTab);
-
-    bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
-    if (In<ELFT>::VerDef || HasVerNeed)
-      addInputSec(In<ELFT>::VerSym);
-    addInputSec(In<ELFT>::VerDef);
-    if (HasVerNeed)
-      addInputSec(In<ELFT>::VerNeed);
-
-    addInputSec(In<ELFT>::GnuHashTab);
-    addInputSec(In<ELFT>::HashTab);
-    addInputSec(In<ELFT>::Dynamic);
-    addInputSec(In<ELFT>::DynStrTab);
-    if (In<ELFT>::RelaDyn->hasRelocs())
-      addInputSec(In<ELFT>::RelaDyn);
-  }
 
   // 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 (In<ELFT>::RelaPlt->hasRelocs())
+  if (In<ELFT>::RelaPlt->isPresent())
     addInputSec(In<ELFT>::RelaPlt);
 
-  // We fill .got and .got.plt sections in scanRelocs(). This is the
-  // reason we don't add it earlier in createSections().
-  if (needsGot()) {
-    if (Config->EMachine == EM_MIPS)
-      addInputSec(In<ELFT>::MipsGot);
-    else
-      addInputSec(In<ELFT>::Got);
-  }
-
-  if (!In<ELFT>::GotPlt->empty())
-    addInputSec(In<ELFT>::GotPlt);
-
   if (!In<ELFT>::Plt->empty())
     addInputSec(In<ELFT>::Plt);
   if (!Out<ELFT>::EhFrame->empty())
     addInputSec(In<ELFT>::EhFrameHdr);
   if (Out<ELFT>::Bss->Size > 0)
     Add(Out<ELFT>::Bss);
 }
 

test/ELF/eh-align-cie.s

 // CHECK-NEXT: Offset:
 // CHECK-NEXT: Size:
 // CHECK-NEXT: Link:
 // CHECK-NEXT: Info:
 // CHECK-NEXT: AddressAlignment:
 // CHECK-NEXT: EntrySize:
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT:   0000: 1C000000 00000000 017A5052 00017810
-// CHECK-NEXT:   0010: 061B260E 00001B0C 07089001 00000000
-// CHECK-NEXT:   0020: 14000000 24000000 100E0000 00000000
+// CHECK-NEXT:   0010: 061BF60D 00001B0C 07089001 00000000
+// CHECK-NEXT:   0020: 14000000 24000000 E00D0000 00000000
 // CHECK-NEXT:   0030: 00000000 00000000
 // CHECK-NEXT: )

test/ELF/eh-frame-hdr-augmentation.s

 // CHECK-NEXT:   Return address column: 16
 // CHECK-NEXT:   Augmentation data:
 
 // CHECK:      DW_CFA_def_cfa:  reg7 +8
 // CHECK-NEXT: DW_CFA_offset:   reg16 -8
 // CHECK-NEXT: DW_CFA_nop:
 // CHECK-NEXT: DW_CFA_nop:
 
-// CHECK:      00000020 00000014 00000024 FDE cie=00000024 pc=00000dd8...00000dd8
+// CHECK:      00000020 00000014 00000024 FDE cie=00000024 pc=00000da8...00000da8
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 
         .cfi_startproc
         .cfi_personality 0x9b, g
         .cfi_lsda 0x1b, h
         .cfi_endproc

test/ELF/eh-frame-marker.s

 // RUN: llvm-mc %s -o %t.o -filetype=obj -triple=x86_64-pc-linux
 // RUN: ld.lld --eh-frame-hdr %t.o -o %t.so -shared
 // RUN: llvm-readobj -t -s %t.so | FileCheck %s
 // We used to crash on this.
 
 // CHECK:      Name: .eh_frame
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT: ]
-// CHECK-NEXT: Address: 0x200
+// CHECK-NEXT: Address: 0x229
 
 // CHECK:      Name: foo
-// CHECK-NEXT: Value: 0x200
+// CHECK-NEXT: Value: 0x229
 
         .section .eh_frame
 foo:
         .long 0

test/ELF/eh-frame-merge.s

 // CHECK-NEXT: Size: 96
 // CHECK-NEXT: Link: 0
 // CHECK-NEXT: Info: 0
 // CHECK-NEXT: AddressAlignment: 8
 // CHECK-NEXT: EntrySize: 0
 // CHECK-NEXT: SectionData (
 // CHECK-NEXT: 0000: 14000000 00000000 017A5200 01781001  |
 // CHECK-NEXT: 0010: 1B0C0708 90010000 14000000 1C000000  |
-// CHECK-NEXT: 0020: 180E0000 01000000 00000000 00000000  |
-// CHECK-NEXT: 0030: 14000000 34000000 020E0000 02000000  |
+// CHECK-NEXT: 0020: E80D0000 01000000 00000000 00000000  |
+// CHECK-NEXT: 0030: 14000000 34000000 D20D0000 02000000  |
 // CHECK-NEXT: 0040: 00000000 00000000 14000000 4C000000  |
-// CHECK-NEXT: 0050: E90D0000 01000000 00000000 00000000  |
+// CHECK-NEXT: 0050: B90D0000 01000000 00000000 00000000  |
 // CHECK-NEXT: )
 
 // CHECK:      Name: foo
 // CHECK-NEXT: Type: SHT_PROGBITS
 // CHECK-NEXT: Flags [
 // CHECK-NEXT:   SHF_ALLOC
 // CHECK-NEXT:   SHF_EXECINSTR
 // CHECK-NEXT: ]

test/ELF/linkerscript/phdrs.s

 # INT-PHDRS-NEXT:      PhysicalAddress: 0xB0
 # INT-PHDRS-NEXT:      FileSize: 9
 # INT-PHDRS-NEXT:      MemSize: 9
 # INT-PHDRS-NEXT:      Flags [
 # INT-PHDRS-NEXT:        PF_R
 # INT-PHDRS-NEXT:        PF_W
 # INT-PHDRS-NEXT:        PF_X
 # INT-PHDRS-NEXT:      ]
-# INT-PHDRS-NEXT:      Alignment: 4
+# INT-PHDRS-NEXT:      Alignment:
 # INT-PHDRS-NEXT:    }
 # INT-PHDRS-NEXT:  ]
 
 # DEFHDR:     ProgramHeaders [
 # DEFHDR-NEXT:  ProgramHeader {
 # DEFHDR-NEXT:    Type: PT_LOAD (0x1)
 # DEFHDR-NEXT:    Offset: 0x0
 # DEFHDR-NEXT:    VirtualAddress: 0x10000000

test/ELF/synthetic-got.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
+# RUN: echo "SECTIONS { }" > %t0.script
+# RUN: ld.lld -shared %t.o -o %t0.out --script %t0.script
+# RUN: llvm-objdump -section-headers %t0.out | FileCheck %s --check-prefix=GOT
+# RUN: llvm-objdump -s -section=.got -section=.got.plt %t0.out \
+# RUN:   | FileCheck %s --check-prefix=GOTDATA
+
+# GOT:     Sections:
+# GOT:      9  .got         00000008 00000000000001b0 DATA
+# GOT-NEXT: 10 .got.plt     00000020 00000000000001b8 DATA
+# GOTDATA:     Contents of section .got:
+# GOTDATA-NEXT:  01b0 00000000 00000000
+# GOTDATA-NEXT: Contents of section .got.plt:
+# GOTDATA-NEXT:  01b8 e0000000 00000000 00000000 00000000
+# GOTDATA-NEXT:  01c8 00000000 00000000 d6000000 00000000
+
+# RUN: echo "SECTIONS { .mygot : { *(.got) *(.got.plt) } }" > %t1.script
+# RUN: ld.lld -shared %t.o -o %t1.out --script %t1.script
+# RUN: llvm-objdump -section-headers %t1.out | FileCheck %s --check-prefix=MYGOT
+# RUN: llvm-objdump -s -section=.mygot %t1.out | FileCheck %s --check-prefix=MYGOTDATA
+
+# MYGOT:     Sections:
+# MYGOT:      9  .mygot     00000028 00000000000001b0 DATA
+# MYGOT-NOT:  .got
+# MYGOT-NOT:  .got.plt
+# MYGOTDATA:      01b0 00000000 00000000 e0000000 00000000
+# MYGOTDATA-NEXT: 01c0 00000000 00000000 00000000 00000000
+# MYGOTDATA-NEXT: 01d0 d6000000 00000000
+
+mov bar@gotpcrel(%rip), %rax
+call foo@plt