[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 ↗

(On Diff #79053)

This looks better

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

255 ↗

(On Diff #79053)

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

723 ↗

(On Diff #79053)

Why are you checking IS for nullptr?

883 ↗

(On Diff #79053)

Why are you checking for null?

889 ↗

(On Diff #79053)

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 ↗

(On Diff #79053)

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

723 ↗

(On Diff #79053)

Forgot to remove after experiments, thanks.

883 ↗

(On Diff #79053)

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.

889 ↗

(On Diff #79053)

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 ↗

(On Diff #79102)

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

ELF/Writer.cpp

878 ↗

(On Diff #79102)

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

881–882 ↗

(On Diff #79102)

Use llvm::reverse.

230 ↗

(On Diff #79053)

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

255 ↗

(On Diff #79053)

For example, I'd write

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

[grimar]

• Addressed review comments.

[grimar]

ELF/SyntheticSections.h

35 ↗

(On Diff #79102)

Done.

ELF/Writer.cpp

878 ↗

(On Diff #79102)

Done.

881–882 ↗

(On Diff #79102)

Done.

230 ↗

(On Diff #79053)

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

[ruiu]

ELF/SyntheticSections.h

35 ↗

(On Diff #79102)

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

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

So, you meant VersionTable is empty if

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

But why?

[grimar]

ELF/SyntheticSections.cpp

1589–1590 ↗

(On Diff #79242)

Mmm, no, it is empty if

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

[ruiu]

ELF/SyntheticSections.cpp

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

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

[ruiu]

ELF/SyntheticSections.cpp

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

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

1589–1590 ↗

(On Diff #79242)

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

[grimar]

ELF/SyntheticSections.cpp

1589–1590 ↗

(On Diff #79242)

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

[ruiu]

LGTM

ELF/SyntheticSections.cpp

1589–1590 ↗

(On Diff #79242)

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

lld/trunk/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 empty() const { return false; }
 
   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 empty() 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; }
   uint32_t getTlsIndexOff() const { return TlsIndexOff; }
 
   // Flag to force GOT to be in output if we have relocations
   // that relies on its address.

 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 empty() const override;
   void addEntry(SymbolBody &Sym, uintX_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
   bool addTlsIndex();
   uintX_t getPageEntryOffset(uintX_t Addr);
   uintX_t getBodyEntryOffset(const SymbolBody &B, uintX_t Addend) const;
   uintX_t getGlobalDynOffset(const SymbolBody &B) const;
 
   // Returns the symbol which corresponds to the first entry of the global part

 
 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 empty() 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 empty() 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;
 };
 

 };
 
 template <class ELFT> class PltSection final : public SyntheticSection<ELFT> {
 public:
   PltSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   void addEntry(SymbolBody &Sym);
-  bool empty() const { return Entries.empty(); }
+  bool empty() const override { return Entries.empty(); }
 
 private:
   std::vector<std::pair<const SymbolBody *, unsigned>> Entries;
 };
 
 template <class ELFT>
 class GdbIndexSection final : public SyntheticSection<ELFT> {
   typedef typename ELFT::uint uintX_t;

 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 empty() 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 empty() 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 empty() 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:

lld/trunk/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>::empty() 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 Entries.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>::empty() 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->Relocatable;
+}
+
 template <class ELFT> unsigned MipsGotSection<ELFT>::getGp() const {
   return ElfSym<ELFT>::MipsGp->template getVA<ELFT>(0);
 }
 
 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);
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->empty()) {
     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->empty()) {
     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>::empty() 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>::empty() const {
+  return !In<ELFT>::VerDef && In<ELFT>::VerNeed->empty();
+}
+
 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>::empty() 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);

lld/trunk/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();
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 {
     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);
   }
 
   InputSection<ELFT> *Common = createCommonSection<ELFT>();
   if (!Common->Data.empty()) {
     In<ELFT>::Common = Common;
     Symtab<ELFT>::X->Sections.push_back(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) {
+    if (!Config->Shared && HasDynSymTab) {
       In<ELFT>::MipsRldMap = make<MipsRldMapSection<ELFT>>();
       Symtab<ELFT>::X->Sections.push_back(In<ELFT>::MipsRldMap);
     }
     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 = make<SymbolTableSection<ELFT>>(*In<ELFT>::DynStrTab);
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::DynSymTab);
+
+    In<ELFT>::VerSym = make<VersionTableSection<ELFT>>();
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::VerSym);
+
+    if (!Config->VersionDefinitions.empty()) {
+      In<ELFT>::VerDef = make<VersionDefinitionSection<ELFT>>();
+      Symtab<ELFT>::X->Sections.push_back(In<ELFT>::VerDef);
+    }
+
+    In<ELFT>::VerNeed = make<VersionNeedSection<ELFT>>();
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::VerNeed);
+
+    if (Config->GnuHash) {
+      In<ELFT>::GnuHashTab = make<GnuHashTableSection<ELFT>>();
+      Symtab<ELFT>::X->Sections.push_back(In<ELFT>::GnuHashTab);
+    }
+
+    if (Config->SysvHash) {
+      In<ELFT>::HashTab = make<HashTableSection<ELFT>>();
+      Symtab<ELFT>::X->Sections.push_back(In<ELFT>::HashTab);
+    }
+
+    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)
+  if (Config->EMachine == EM_MIPS) {
     In<ELFT>::MipsGot = make<MipsGotSection<ELFT>>();
-  else
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::MipsGot);
+  } else {
     In<ELFT>::Got = make<GotSection<ELFT>>();
+    Symtab<ELFT>::X->Sections.push_back(In<ELFT>::Got);
+  }
 
   In<ELFT>::GotPlt = make<GotPltSection<ELFT>>();
+  Symtab<ELFT>::X->Sections.push_back(In<ELFT>::GotPlt);
 }
 
 template <class ELFT>
 static bool shouldKeepInSymtab(InputSectionBase<ELFT> *Sec, StringRef SymName,
                                const SymbolBody &B) {
   if (B.isFile())
     return false;
 
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 input 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 removeUnusedSyntheticSections(std::vector<OutputSectionBase *> &V) {
+  // Input synthetic sections are placed after all regular ones. We iterate over
+  // them all and exit at first non-synthetic.
+  for (InputSectionBase<ELFT> *S : llvm::reverse(Symtab<ELFT>::X->Sections)) {
+    SyntheticSection<ELFT> *SS = dyn_cast<SyntheticSection<ELFT>>(S);
+    if (!SS)
+      return;
+    if (!SS->empty() || !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 (ErrorCount)
     return;
 
   // So far we have added sections from input object files.
   // This function adds linker-created Out<ELFT>::* sections.
   addPredefinedSections();
+  removeUnusedSyntheticSections<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->empty())
     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);
 
   auto OS = dyn_cast_or_null<OutputSection<ELFT>>(findSection(".ARM.exidx"));

lld/trunk/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: )

lld/trunk/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

lld/trunk/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

lld/trunk/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: ]

lld/trunk/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

lld/trunk/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