Index: ELF/Relocations.h
===================================================================
--- ELF/Relocations.h
+++ ELF/Relocations.h
@@ -112,7 +112,7 @@
 template <class ELFT> void scanRelocations(InputSectionBase<ELFT> &);
 
 template <class ELFT>
-void createThunks(ArrayRef<OutputSectionBase *> OutputSections);
+bool createThunks(ArrayRef<OutputSectionBase *> OutputSections);
 
 // Return a int64_t to make sure we get the sign extension out of the way as
 // early as possible.
Index: ELF/Relocations.cpp
===================================================================
--- ELF/Relocations.cpp
+++ ELF/Relocations.cpp
@@ -856,10 +856,11 @@
 // finalized. If any Thunks are added to an OutputSection the output section
 // offsets of the InputSections will change.
 //
+// Returns true if Thunks have been added.
 // FIXME: All Thunks are assumed to be in range of the relocation. Range
 // extension Thunks are not yet supported.
 template <class ELFT>
-void createThunks(ArrayRef<OutputSectionBase *> OutputSections) {
+bool createThunks(ArrayRef<OutputSectionBase *> OutputSections) {
   // Track Symbols that already have a Thunk
   DenseMap<SymbolBody *, Thunk<ELFT> *> ThunkedSymbols;
   // Track InputSections that have a ThunkSection placed in front
@@ -941,6 +942,7 @@
   // Merge all created synthetic ThunkSections back into OutputSection
   for (auto &KV : ThunkSections)
     mergeThunks<ELFT>(KV.first, KV.second);
+  return !ThunkSections.empty();
 }
 
 template void scanRelocations<ELF32LE>(InputSectionBase<ELF32LE> &);
@@ -948,9 +950,9 @@
 template void scanRelocations<ELF64LE>(InputSectionBase<ELF64LE> &);
 template void scanRelocations<ELF64BE>(InputSectionBase<ELF64BE> &);
 
-template void createThunks<ELF32LE>(ArrayRef<OutputSectionBase *>);
-template void createThunks<ELF32BE>(ArrayRef<OutputSectionBase *>);
-template void createThunks<ELF64LE>(ArrayRef<OutputSectionBase *>);
-template void createThunks<ELF64BE>(ArrayRef<OutputSectionBase *>);
+template bool createThunks<ELF32LE>(ArrayRef<OutputSectionBase *>);
+template bool createThunks<ELF32BE>(ArrayRef<OutputSectionBase *>);
+template bool createThunks<ELF64LE>(ArrayRef<OutputSectionBase *>);
+template bool createThunks<ELF64BE>(ArrayRef<OutputSectionBase *>);
 }
 }
Index: ELF/SyntheticSections.h
===================================================================
--- ELF/SyntheticSections.h
+++ ELF/SyntheticSections.h
@@ -48,6 +48,7 @@
   virtual void writeTo(uint8_t *Buf) = 0;
   virtual size_t getSize() const = 0;
   virtual void finalize() {}
+  virtual void updateAllocSize() {}
   virtual bool empty() const { return false; }
 
   uintX_t getVA() const {
@@ -67,6 +68,7 @@
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void finalize() override;
+  void updateAllocSize() override;
   bool empty() const override;
 
   void addEntry(SymbolBody &Sym);
@@ -129,6 +131,7 @@
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void finalize() override;
+  void updateAllocSize() override;
   bool empty() const override;
   void addEntry(SymbolBody &Sym, int64_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
@@ -337,11 +340,13 @@
 public:
   DynamicSection();
   void finalize() override;
+  void updateAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
 
 private:
   void addEntries();
+  std::vector<Entry> addLateEntries();
   void add(Entry E) { Entries.push_back(E); }
   uintX_t Size = 0;
 };
@@ -394,6 +399,7 @@
   ArrayRef<SymbolTableEntry> getSymbols() const { return Symbols; }
 
   static const OutputSectionBase *getOutputSection(SymbolBody *Sym);
+  void addSymbolsToGnuHashTab();
 
 private:
   void writeLocalSymbols(uint8_t *&Buf);
@@ -418,6 +424,7 @@
 public:
   GnuHashTableSection();
   void finalize() override;
+  void updateAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
 
@@ -454,6 +461,7 @@
 public:
   HashTableSection();
   void finalize() override;
+  void updateAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
 
@@ -572,6 +580,7 @@
 public:
   VersionDefinitionSection();
   void finalize() override;
+  void updateAllocSize() override;
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
 
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -441,10 +441,12 @@
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
-template <class ELFT> void GotSection<ELFT>::finalize() {
+template <class ELFT> void GotSection<ELFT>::updateAllocSize() {
   Size = NumEntries * sizeof(uintX_t);
 }
 
+template <class ELFT> void GotSection<ELFT>::finalize() { updateAllocSize(); }
+
 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.
@@ -619,7 +621,7 @@
          LocalEntries32.size();
 }
 
-template <class ELFT> void MipsGotSection<ELFT>::finalize() {
+template <class ELFT> void MipsGotSection<ELFT>::updateAllocSize() {
   PageEntriesNum = 0;
   for (std::pair<const OutputSectionBase *, size_t> &P : PageIndexMap) {
     // For each output section referenced by GOT page relocations calculate
@@ -635,6 +637,10 @@
          sizeof(uintX_t);
 }
 
+template <class ELFT> void MipsGotSection<ELFT>::finalize() {
+  updateAllocSize();
+}
+
 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.
@@ -857,18 +863,17 @@
     add({DT_DEBUG, (uint64_t)0});
 }
 
-// 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;
+template <class ELFT>
+std::vector<typename DynamicSection<ELFT>::Entry>
+DynamicSection<ELFT>::addLateEntries() {
+  std::vector<Entry> LateEntries;
+  auto AddLate = [&](Entry E) { LateEntries.push_back(E); };
   if (In<ELFT>::RelaDyn->OutSec->Size > 0) {
     bool IsRela = Config->Rela;
-    add({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
-    add({IsRela ? DT_RELASZ : DT_RELSZ, In<ELFT>::RelaDyn->OutSec->Size});
-    add({IsRela ? DT_RELAENT : DT_RELENT,
-         uintX_t(IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel))});
+    AddLate({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
+    AddLate({IsRela ? DT_RELASZ : DT_RELSZ, In<ELFT>::RelaDyn->OutSec->Size});
+    AddLate({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
@@ -876,74 +881,87 @@
     if (Config->EMachine != EM_MIPS) {
       size_t NumRelativeRels = In<ELFT>::RelaDyn->getRelativeRelocCount();
       if (Config->ZCombreloc && NumRelativeRels)
-        add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
+        AddLate({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
     }
   }
   if (In<ELFT>::RelaPlt->OutSec->Size > 0) {
-    add({DT_JMPREL, In<ELFT>::RelaPlt});
-    add({DT_PLTRELSZ, In<ELFT>::RelaPlt->OutSec->Size});
-    add({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
-         In<ELFT>::GotPlt});
-    add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
+    AddLate({DT_JMPREL, In<ELFT>::RelaPlt});
+    AddLate({DT_PLTRELSZ, In<ELFT>::RelaPlt->OutSec->Size});
+    AddLate({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
+             In<ELFT>::GotPlt});
+    AddLate({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
   }
 
-  add({DT_SYMTAB, In<ELFT>::DynSymTab});
-  add({DT_SYMENT, sizeof(Elf_Sym)});
-  add({DT_STRTAB, In<ELFT>::DynStrTab});
-  add({DT_STRSZ, In<ELFT>::DynStrTab->getSize()});
+  AddLate({DT_SYMTAB, In<ELFT>::DynSymTab});
+  AddLate({DT_SYMENT, sizeof(Elf_Sym)});
+  AddLate({DT_STRTAB, In<ELFT>::DynStrTab});
+  AddLate({DT_STRSZ, In<ELFT>::DynStrTab->getSize()});
   if (In<ELFT>::GnuHashTab)
-    add({DT_GNU_HASH, In<ELFT>::GnuHashTab});
+    AddLate({DT_GNU_HASH, In<ELFT>::GnuHashTab});
   if (In<ELFT>::HashTab)
-    add({DT_HASH, In<ELFT>::HashTab});
+    AddLate({DT_HASH, In<ELFT>::HashTab});
 
   if (Out<ELFT>::PreinitArray) {
-    add({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
-    add({DT_PREINIT_ARRAYSZ, Out<ELFT>::PreinitArray, Entry::SecSize});
+    AddLate({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
+    AddLate({DT_PREINIT_ARRAYSZ, Out<ELFT>::PreinitArray, Entry::SecSize});
   }
   if (Out<ELFT>::InitArray) {
-    add({DT_INIT_ARRAY, Out<ELFT>::InitArray});
-    add({DT_INIT_ARRAYSZ, Out<ELFT>::InitArray, Entry::SecSize});
+    AddLate({DT_INIT_ARRAY, Out<ELFT>::InitArray});
+    AddLate({DT_INIT_ARRAYSZ, Out<ELFT>::InitArray, Entry::SecSize});
   }
   if (Out<ELFT>::FiniArray) {
-    add({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
-    add({DT_FINI_ARRAYSZ, Out<ELFT>::FiniArray, Entry::SecSize});
+    AddLate({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
+    AddLate({DT_FINI_ARRAYSZ, Out<ELFT>::FiniArray, Entry::SecSize});
   }
 
   if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Init))
-    add({DT_INIT, B});
+    AddLate({DT_INIT, B});
   if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Fini))
-    add({DT_FINI, B});
+    AddLate({DT_FINI, B});
 
   bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
   if (HasVerNeed || In<ELFT>::VerDef)
-    add({DT_VERSYM, In<ELFT>::VerSym});
+    AddLate({DT_VERSYM, In<ELFT>::VerSym});
   if (In<ELFT>::VerDef) {
-    add({DT_VERDEF, In<ELFT>::VerDef});
-    add({DT_VERDEFNUM, getVerDefNum()});
+    AddLate({DT_VERDEF, In<ELFT>::VerDef});
+    AddLate({DT_VERDEFNUM, getVerDefNum()});
   }
   if (HasVerNeed) {
-    add({DT_VERNEED, In<ELFT>::VerNeed});
-    add({DT_VERNEEDNUM, In<ELFT>::VerNeed->getNeedNum()});
+    AddLate({DT_VERNEED, In<ELFT>::VerNeed});
+    AddLate({DT_VERNEEDNUM, In<ELFT>::VerNeed->getNeedNum()});
   }
 
   if (Config->EMachine == EM_MIPS) {
-    add({DT_MIPS_RLD_VERSION, 1});
-    add({DT_MIPS_FLAGS, RHF_NOTPOT});
-    add({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
-    add({DT_MIPS_SYMTABNO, In<ELFT>::DynSymTab->getNumSymbols()});
-    add({DT_MIPS_LOCAL_GOTNO, In<ELFT>::MipsGot->getLocalEntriesNum()});
+    AddLate({DT_MIPS_RLD_VERSION, 1});
+    AddLate({DT_MIPS_FLAGS, RHF_NOTPOT});
+    AddLate({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
+    AddLate({DT_MIPS_SYMTABNO, In<ELFT>::DynSymTab->getNumSymbols()});
+    AddLate({DT_MIPS_LOCAL_GOTNO, In<ELFT>::MipsGot->getLocalEntriesNum()});
     if (const SymbolBody *B = In<ELFT>::MipsGot->getFirstGlobalEntry())
-      add({DT_MIPS_GOTSYM, B->DynsymIndex});
+      AddLate({DT_MIPS_GOTSYM, B->DynsymIndex});
     else
-      add({DT_MIPS_GOTSYM, In<ELFT>::DynSymTab->getNumSymbols()});
-    add({DT_PLTGOT, In<ELFT>::MipsGot});
+      AddLate({DT_MIPS_GOTSYM, In<ELFT>::DynSymTab->getNumSymbols()});
+    AddLate({DT_PLTGOT, In<ELFT>::MipsGot});
     if (In<ELFT>::MipsRldMap)
-      add({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
+      AddLate({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
   }
+  return LateEntries;
+}
 
+// Add remaining entries to complete .dynamic contents.
+template <class ELFT> void DynamicSection<ELFT>::updateAllocSize() {
+  std::vector<Entry> LateEntries = addLateEntries();
+  // +1 for DT_NULL
+  this->Size = (Entries.size() + LateEntries.size() + 1) * this->Entsize;
+}
+
+// Add remaining entries to complete .dynamic contents.
+template <class ELFT> void DynamicSection<ELFT>::finalize() {
+  this->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
+  std::vector<Entry> LateEntries = addLateEntries();
+  Entries.insert(Entries.end(), LateEntries.begin(), LateEntries.end());
   this->OutSec->Entsize = this->Entsize;
   this->OutSec->Link = this->Link;
-
   // +1 for DT_NULL
   this->Size = (Entries.size() + 1) * this->Entsize;
 }
@@ -1111,10 +1129,7 @@
     return;
   }
 
-  if (In<ELFT>::GnuHashTab)
-    // NB: It also sorts Symbols to meet the GNU hash table requirements.
-    In<ELFT>::GnuHashTab->addSymbols(Symbols);
-  else if (Config->EMachine == EM_MIPS)
+  if (Config->EMachine == EM_MIPS)
     std::stable_sort(Symbols.begin(), Symbols.end(),
                      [](const SymbolTableEntry &L, const SymbolTableEntry &R) {
                        return sortMipsSymbols(L.Symbol, R.Symbol);
@@ -1262,6 +1277,12 @@
   return nullptr;
 }
 
+template <class ELFT> void SymbolTableSection<ELFT>::addSymbolsToGnuHashTab() {
+  assert(In<ELFT>::GnuHashTab && StrTabSec.isDynamic());
+  // NB: It also sorts Symbols to meet the GNU hash table requirements.
+  In<ELFT>::GnuHashTab->addSymbols(Symbols);
+}
+
 template <class ELFT>
 GnuHashTableSection<ELFT>::GnuHashTableSection()
     : SyntheticSection<ELFT>(SHF_ALLOC, SHT_GNU_HASH, sizeof(uintX_t),
@@ -1303,21 +1324,24 @@
   return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
 }
 
-template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
+template <class ELFT> void GnuHashTableSection<ELFT>::updateAllocSize() {
   unsigned NumHashed = Symbols.size();
   NBuckets = calcNBuckets(NumHashed);
   MaskWords = calcMaskWords(NumHashed);
   // Second hash shift estimation: just predefined values.
   Shift2 = ELFT::Is64Bits ? 6 : 5;
-
-  this->OutSec->Entsize = this->Entsize;
-  this->OutSec->Link = this->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
   this->Size = sizeof(Elf_Word) * 4            // Header
                + sizeof(Elf_Off) * MaskWords   // Bloom Filter
                + sizeof(Elf_Word) * NBuckets   // Hash Buckets
                + sizeof(Elf_Word) * NumHashed; // Hash Values
 }
 
+template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
+  updateAllocSize();
+  this->OutSec->Entsize = this->Entsize;
+  this->OutSec->Link = this->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
+}
+
 template <class ELFT> void GnuHashTableSection<ELFT>::writeTo(uint8_t *Buf) {
   writeHeader(Buf);
   if (Symbols.empty())
@@ -1381,7 +1405,7 @@
 }
 
 // Add symbols to this symbol hash table. Note that this function
-// destructively sort a given vector -- which is needed because
+// destructively sorts a given vector -- which is needed because
 // GNU-style hash table places some sorting requirements.
 template <class ELFT>
 void GnuHashTableSection<ELFT>::addSymbols(std::vector<SymbolTableEntry> &V) {
@@ -1416,10 +1440,7 @@
   this->Entsize = sizeof(Elf_Word);
 }
 
-template <class ELFT> void HashTableSection<ELFT>::finalize() {
-  this->OutSec->Link = this->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
-  this->OutSec->Entsize = this->Entsize;
-
+template <class ELFT> void HashTableSection<ELFT>::updateAllocSize() {
   unsigned NumEntries = 2;                            // nbucket and nchain.
   NumEntries += In<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
 
@@ -1430,6 +1451,12 @@
   this->Size = NumEntries * sizeof(Elf_Word);
 }
 
+template <class ELFT> void HashTableSection<ELFT>::finalize() {
+  updateAllocSize();
+  this->OutSec->Link = this->Link = In<ELFT>::DynSymTab->OutSec->SectionIndex;
+  this->OutSec->Entsize = this->Entsize;
+}
+
 template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
   unsigned NumSymbols = In<ELFT>::DynSymTab->getNumSymbols();
   auto *P = reinterpret_cast<Elf_Word *>(Buf);
@@ -1710,11 +1737,15 @@
   return Config->OutputFile;
 }
 
-template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+template <class ELFT> void VersionDefinitionSection<ELFT>::updateAllocSize() {
+  // Careful to only do this once
   FileDefNameOff = In<ELFT>::DynStrTab->addString(getFileDefName());
   for (VersionDefinition &V : Config->VersionDefinitions)
     V.NameOff = In<ELFT>::DynStrTab->addString(V.Name);
+}
 
+template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+  updateAllocSize();
   this->OutSec->Link = this->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
 
   // sh_info should be set to the number of definitions. This fact is missed in
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -1047,6 +1047,17 @@
     }
 }
 
+template <class ELFT>
+static void updateSyntheticAllocSize(
+    const std::vector<SyntheticSection<ELFT> *> &Sections) {
+  for (SyntheticSection<ELFT> *SS : Sections)
+    if (SS && SS->OutSec && !SS->empty()) {
+      SS->updateAllocSize();
+      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
@@ -1118,10 +1129,10 @@
     SymbolBody *Body = S->body();
 
     if (!includeInSymtab<ELFT>(*Body))
-      continue;    
+      continue;
     if (In<ELFT>::SymTab)
       In<ELFT>::SymTab->addGlobal(Body);
-    
+
     if (In<ELFT>::DynSymTab && S->includeInDynsym()) {
       In<ELFT>::DynSymTab->addGlobal(Body);
       if (auto *SS = dyn_cast<SharedSymbol<ELFT>>(Body))
@@ -1129,6 +1140,8 @@
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
+  if (In<ELFT>::GnuHashTab && In<ELFT>::DynSymTab)
+    In<ELFT>::DynSymTab->addSymbolsToGnuHashTab();
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)
@@ -1162,11 +1175,29 @@
     fixHeaders();
   }
 
+  std::vector<SyntheticSection<ELFT> *> Synthetics = {
+      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>::IgotPlt,
+      In<ELFT>::GotPlt,    In<ELFT>::RelaDyn,    In<ELFT>::RelaIplt,
+      In<ELFT>::RelaPlt,   In<ELFT>::Plt,        In<ELFT>::Iplt,
+      In<ELFT>::Plt,       In<ELFT>::EhFrameHdr, In<ELFT>::VerSym,
+      In<ELFT>::VerNeed,   In<ELFT>::Dynamic};
+
   // Some architectures use small displacements for jump instructions.
   // It is linker's responsibility to create thunks containing long
   // jump instructions if jump targets are too far. Create thunks.
-  if (Target->NeedsThunks)
-    createThunks<ELFT>(OutputSections);
+  if (Target->NeedsThunks) {
+    // FIXME: only ARM Interworking and Mips LA25 Thunks are implemented, these
+    // do not require address information. To support range extension Thunks
+    // we need to assign addresses so that we can tell if jump instructions
+    // are out of range. This will need to turn into a loop that converges
+    // when no more Thunks are added
+    updateSyntheticAllocSize<ELFT>(Synthetics);
+    if (createThunks<ELFT>(OutputSections))
+      updateSyntheticAllocSize<ELFT>(Synthetics);
+  }
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
@@ -1176,15 +1207,7 @@
 
   // Dynamic section must be the last one in this list and dynamic
   // symbol table section (DynSymTab) must be the first one.
-  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>::IgotPlt,
-       In<ELFT>::GotPlt,    In<ELFT>::RelaDyn,    In<ELFT>::RelaIplt,
-       In<ELFT>::RelaPlt,   In<ELFT>::Plt,        In<ELFT>::Iplt,
-       In<ELFT>::Plt,       In<ELFT>::EhFrameHdr, In<ELFT>::VerSym,
-       In<ELFT>::VerNeed,   In<ELFT>::Dynamic});
+  finalizeSynthetic<ELFT>(Synthetics);
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {