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 finalizeAllocSize() {}
   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 finalizeAllocSize() override;
   bool empty() const override;
 
   void addEntry(SymbolBody &Sym);
@@ -128,6 +130,7 @@
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
   void finalize() override;
+  void finalizeAllocSize() override;
   bool empty() const override;
   void addEntry(SymbolBody &Sym, uintX_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
@@ -335,7 +338,9 @@
 
 public:
   DynamicSection();
+  void applyEntries(bool Reserve);
   void finalize() override;
+  void finalizeAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
 
@@ -382,6 +387,7 @@
   SymbolTableSection(StringTableSection<ELFT> &StrTabSec);
 
   void finalize() override;
+  void finalizeAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return getNumSymbols() * sizeof(Elf_Sym); }
   void addGlobal(SymbolBody *Body);
@@ -417,6 +423,7 @@
 public:
   GnuHashTableSection();
   void finalize() override;
+  void finalizeAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
 
@@ -453,6 +460,7 @@
 public:
   HashTableSection();
   void finalize() override;
+  void finalizeAllocSize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
 
@@ -571,6 +579,7 @@
 public:
   VersionDefinitionSection();
   void finalize() override;
+  void finalizeAllocSize() 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,14 @@
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
-template <class ELFT> void GotSection<ELFT>::finalize() {
+template <class ELFT> void GotSection<ELFT>::finalizeAllocSize() {
   Size = NumEntries * sizeof(uintX_t);
 }
 
+template <class ELFT> void GotSection<ELFT>::finalize() {
+  assert(Size == NumEntries * 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.
@@ -619,7 +623,7 @@
          LocalEntries32.size();
 }
 
-template <class ELFT> void MipsGotSection<ELFT>::finalize() {
+template <class ELFT> void MipsGotSection<ELFT>::finalizeAllocSize() {
   PageEntriesNum = 0;
   for (std::pair<const OutputSectionBase *, size_t> &P : PageIndexMap) {
     // For each output section referenced by GOT page relocations calculate
@@ -635,6 +639,22 @@
          sizeof(uintX_t);
 }
 
+template <class ELFT> void MipsGotSection<ELFT>::finalize() {
+  PageEntriesNum = 0;
+  for (std::pair<const OutputSectionBase *, size_t> &P : PageIndexMap) {
+    // For each output section referenced by GOT page relocations calculate
+    // and save into PageIndexMap an upper bound of MIPS GOT entries required
+    // to store page addresses of local symbols. We assume the worst case -
+    // each 64kb page of the output section has at least one GOT relocation
+    // against it. And take in account the case when the section intersects
+    // page boundaries.
+    P.second = PageEntriesNum;
+    PageEntriesNum += getMipsPageCount(P.first->Size);
+  }
+  assert (Size == (getLocalEntriesNum() + GlobalEntries.size() + TlsEntries.size()) *
+          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.
@@ -857,17 +877,18 @@
     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;
-  if (In<ELFT>::RelaDyn->OutSec->Size > 0) {
+template <class ELFT> void DynamicSection<ELFT>::applyEntries(bool Reserve) {
+  auto Apply = [this, Reserve](Entry E){
+    if (Reserve)
+      this->Size += this->Entsize;
+    else
+      this->Entries.push_back(E);
+  };
+  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->OutSec->Size});
-    add({IsRela ? DT_RELAENT : DT_RELENT,
+    Apply({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
+    Apply({IsRela ? DT_RELASZ : DT_RELSZ, In<ELFT>::RelaDyn->OutSec->Size});
+    Apply({IsRela ? DT_RELAENT : DT_RELENT,
          uintX_t(IsRela ? sizeof(Elf_Rela) : sizeof(Elf_Rel))});
 
     // MIPS dynamic loader does not support RELCOUNT tag.
@@ -876,76 +897,88 @@
     if (Config->EMachine != EM_MIPS) {
       size_t NumRelativeRels = In<ELFT>::RelaDyn->getRelativeRelocCount();
       if (Config->ZCombreloc && NumRelativeRels)
-        add({IsRela ? DT_RELACOUNT : DT_RELCOUNT, NumRelativeRels});
+        Apply({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,
+  if (!In<ELFT>::RelaPlt->empty()) {
+    Apply({DT_JMPREL, In<ELFT>::RelaPlt});
+    Apply({DT_PLTRELSZ, In<ELFT>::RelaPlt->OutSec->Size});
+    Apply({Config->EMachine == EM_MIPS ? DT_MIPS_PLTGOT : DT_PLTGOT,
          In<ELFT>::GotPlt});
-    add({DT_PLTREL, uint64_t(Config->Rela ? DT_RELA : DT_REL)});
+    Apply({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()});
+  Apply({DT_SYMTAB, In<ELFT>::DynSymTab});
+  Apply({DT_SYMENT, sizeof(Elf_Sym)});
+  Apply({DT_STRTAB, In<ELFT>::DynStrTab});
+  Apply({DT_STRSZ, In<ELFT>::DynStrTab->getSize()});
   if (In<ELFT>::GnuHashTab)
-    add({DT_GNU_HASH, In<ELFT>::GnuHashTab});
+    Apply({DT_GNU_HASH, In<ELFT>::GnuHashTab});
   if (In<ELFT>::HashTab)
-    add({DT_HASH, In<ELFT>::HashTab});
+    Apply({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});
+    Apply({DT_PREINIT_ARRAY, Out<ELFT>::PreinitArray});
+    Apply({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});
+    Apply({DT_INIT_ARRAY, Out<ELFT>::InitArray});
+    Apply({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});
+    Apply({DT_FINI_ARRAY, Out<ELFT>::FiniArray});
+    Apply({DT_FINI_ARRAYSZ, Out<ELFT>::FiniArray, Entry::SecSize});
   }
 
   if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Init))
-    add({DT_INIT, B});
+    Apply({DT_INIT, B});
   if (SymbolBody *B = Symtab<ELFT>::X->findInCurrentDSO(Config->Fini))
-    add({DT_FINI, B});
+    Apply({DT_FINI, B});
 
   bool HasVerNeed = In<ELFT>::VerNeed->getNeedNum() != 0;
   if (HasVerNeed || In<ELFT>::VerDef)
-    add({DT_VERSYM, In<ELFT>::VerSym});
+    Apply({DT_VERSYM, In<ELFT>::VerSym});
   if (In<ELFT>::VerDef) {
-    add({DT_VERDEF, In<ELFT>::VerDef});
-    add({DT_VERDEFNUM, getVerDefNum()});
+    Apply({DT_VERDEF, In<ELFT>::VerDef});
+    Apply({DT_VERDEFNUM, getVerDefNum()});
   }
   if (HasVerNeed) {
-    add({DT_VERNEED, In<ELFT>::VerNeed});
-    add({DT_VERNEEDNUM, In<ELFT>::VerNeed->getNeedNum()});
+    Apply({DT_VERNEED, In<ELFT>::VerNeed});
+    Apply({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()});
+    Apply({DT_MIPS_RLD_VERSION, 1});
+    Apply({DT_MIPS_FLAGS, RHF_NOTPOT});
+    Apply({DT_MIPS_BASE_ADDRESS, Config->ImageBase});
+    Apply({DT_MIPS_SYMTABNO, In<ELFT>::DynSymTab->getNumSymbols()});
+    Apply({DT_MIPS_LOCAL_GOTNO, In<ELFT>::MipsGot->getLocalEntriesNum()});
     if (const SymbolBody *B = In<ELFT>::MipsGot->getFirstGlobalEntry())
-      add({DT_MIPS_GOTSYM, B->DynsymIndex});
+      Apply({DT_MIPS_GOTSYM, B->DynsymIndex});
     else
-      add({DT_MIPS_GOTSYM, In<ELFT>::DynSymTab->getNumSymbols()});
-    add({DT_PLTGOT, In<ELFT>::MipsGot});
+      Apply({DT_MIPS_GOTSYM, In<ELFT>::DynSymTab->getNumSymbols()});
+    Apply({DT_PLTGOT, In<ELFT>::MipsGot});
     if (In<ELFT>::MipsRldMap)
-      add({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
+      Apply({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
   }
+}
+
+// Add remaining entries to complete .dynamic contents.
+template <class ELFT> void DynamicSection<ELFT>::finalizeAllocSize() {
+  this->Size = (Entries.size() + 1) * this->Entsize;
+  applyEntries(true /*Reserve*/);
+}
+
+// Add remaining entries to complete .dynamic contents.
+template <class ELFT> void DynamicSection<ELFT>::finalize() {
+  this->Link = In<ELFT>::DynStrTab->OutSec->SectionIndex;
+  applyEntries(false /*Reserve*/);
 
   this->OutSec->Entsize = this->Entsize;
   this->OutSec->Link = this->Link;
 
   // +1 for DT_NULL
-  this->Size = (Entries.size() + 1) * this->Entsize;
+  assert(this->Size == (Entries.size() + 1) * this->Entsize);
 }
 
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
@@ -1084,26 +1117,9 @@
   return L->GotIndex < R->GotIndex;
 }
 
-template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
-  this->OutSec->Link = this->Link = StrTabSec.OutSec->SectionIndex;
-  this->OutSec->Info = this->Info = NumLocals + 1;
-  this->OutSec->Entsize = this->Entsize;
-
-  if (Config->Relocatable)
-    return;
-
-  if (!StrTabSec.isDynamic()) {
-    auto GlobBegin = Symbols.begin() + NumLocals;
-    auto It = std::stable_partition(
-        GlobBegin, Symbols.end(), [](const SymbolTableEntry &S) {
-          return S.Symbol->symbol()->computeBinding() == STB_LOCAL;
-        });
-    // update sh_info with number of Global symbols output with computed
-    // binding of STB_LOCAL
-    this->OutSec->Info = this->Info = 1 + (It - Symbols.begin());
+template <class ELFT> void SymbolTableSection<ELFT>::finalizeAllocSize() {
+  if (Config->Relocatable || !StrTabSec.isDynamic())
     return;
-  }
-
   if (In<ELFT>::GnuHashTab)
     // NB: It also sorts Symbols to meet the GNU hash table requirements.
     In<ELFT>::GnuHashTab->addSymbols(Symbols);
@@ -1117,6 +1133,23 @@
     S.Symbol->DynsymIndex = ++I;
 }
 
+template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
+  this->OutSec->Link = this->Link = StrTabSec.OutSec->SectionIndex;
+  this->OutSec->Info = this->Info = NumLocals + 1;
+  this->OutSec->Entsize = this->Entsize;
+
+  if (Config->Relocatable || StrTabSec.isDynamic())
+    return;
+  auto GlobBegin = Symbols.begin() + NumLocals;
+  auto It = std::stable_partition(
+      GlobBegin, Symbols.end(), [](const SymbolTableEntry &S) {
+        return S.Symbol->symbol()->computeBinding() == STB_LOCAL;
+      });
+  // update sh_info with number of Global symbols output with computed
+  // binding of STB_LOCAL
+  this->OutSec->Info = this->Info = 1 + (It - Symbols.begin());
+}
+
 template <class ELFT> void SymbolTableSection<ELFT>::addGlobal(SymbolBody *B) {
   Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
 }
@@ -1297,21 +1330,33 @@
   return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
 }
 
-template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
+template <class ELFT> void GnuHashTableSection<ELFT>::finalizeAllocSize() {
   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() {
+  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;
+  assert(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>::writeTo(uint8_t *Buf) {
   writeHeader(Buf);
   if (Symbols.empty())
@@ -1410,6 +1455,17 @@
   this->Entsize = sizeof(Elf_Word);
 }
 
+template <class ELFT> void HashTableSection<ELFT>::finalizeAllocSize() {
+  unsigned NumEntries = 2;                            // nbucket and nchain.
+  NumEntries += In<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
+
+  // Create as many buckets as there are symbols.
+  // FIXME: This is simplistic. We can try to optimize it, but implementing
+  // support for SHT_GNU_HASH is probably even more profitable.
+  NumEntries += In<ELFT>::DynSymTab->getNumSymbols();
+  this->Size = NumEntries * 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;
@@ -1421,7 +1477,7 @@
   // FIXME: This is simplistic. We can try to optimize it, but implementing
   // support for SHT_GNU_HASH is probably even more profitable.
   NumEntries += In<ELFT>::DynSymTab->getNumSymbols();
-  this->Size = NumEntries * sizeof(Elf_Word);
+  assert(this->Size == NumEntries * sizeof(Elf_Word));
 }
 
 template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
@@ -1704,11 +1760,13 @@
   return Config->OutputFile;
 }
 
-template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+template <class ELFT> void VersionDefinitionSection<ELFT>::finalizeAllocSize() {
   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() {
   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
@@ -1037,6 +1037,19 @@
   for (SyntheticSection<ELFT> *SS : Sections)
     if (SS && SS->OutSec && !SS->empty()) {
       SS->finalize();
+      if (!(SS->OutSec->Flags & SHF_ALLOC)) {
+        SS->OutSec->Size = 0;
+        SS->OutSec->assignOffsets();
+      }
+    }
+}
+
+template <class ELFT>
+static void finalizeSyntheticAllocSize(
+    const std::vector<SyntheticSection<ELFT> *> &Sections) {
+  for (SyntheticSection<ELFT> *SS : Sections)
+    if (SS && SS->OutSec && !SS->empty()) {
+      SS->finalizeAllocSize();
       SS->OutSec->Size = 0;
       SS->OutSec->assignOffsets();
     }
@@ -1107,21 +1120,13 @@
   if (In<ELFT>::Iplt && !In<ELFT>::Iplt->empty())
     In<ELFT>::Iplt->addSymbols();
 
-  // 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);
-
-  // Now that we have defined all possible symbols including linker-
-  // synthesized ones. Visit all symbols to give the finishing touches.
+  // Now that we have defined all possible global symbols including linker-
+  // synthesized ones. Visit all dynamic symbols to give the finishing touches.
   for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     SymbolBody *Body = S->body();
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
-    if (In<ELFT>::SymTab)
-      In<ELFT>::SymTab->addGlobal(Body);
 
     if (In<ELFT>::DynSymTab && S->includeInDynsym()) {
       In<ELFT>::DynSymTab->addGlobal(Body);
@@ -1163,6 +1168,36 @@
     fixHeaders();
   }
 
+  // Finalize the size of these SHF_ALLOC sections, this permits us to
+  // calculate addresses of SHF_ALLOC sections for Thunks.
+  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};
+  finalizeSyntheticAllocSize<ELFT>(Synthetics);
+
+  // 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);
+
+  // Now that we have defined all possible static symbols including linker-
+  // synthesized ones. Visit all static symbols to give the finishing touches.
+  for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
+    SymbolBody *Body = S->body();
+
+    if (!includeInSymtab<ELFT>(*Body))
+      continue;
+    if (In<ELFT>::SymTab)
+      In<ELFT>::SymTab->addGlobal(Body);
+  }
+
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
   // of finalizing other sections.
@@ -1170,16 +1205,9 @@
     Sec->finalize();
 
   // 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});
+  // symbol table section (DynSymTab) must be the first one. The finalize
+  // must not change the size of a SHF_ALLOC section.
+  finalizeSynthetic<ELFT>(Synthetics);
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {
@@ -1189,8 +1217,10 @@
     OutputSections.push_back(Out<ELFT>::BssRelRo);
 
   auto OS = dyn_cast_or_null<OutputSection<ELFT>>(findSection(".ARM.exidx"));
-  if (OS && !OS->Sections.empty() && !Config->Relocatable)
+  if (OS && !OS->Sections.empty() && !Config->Relocatable) {
     OS->addSection(make<ARMExidxSentinelSection<ELFT>>());
+    OS->Size += 8;
+  }
 }
 
 // The linker is expected to define SECNAME_start and SECNAME_end