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
@@ -897,10 +897,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
@@ -982,6 +983,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> &);
@@ -989,9 +991,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
@@ -47,6 +47,12 @@
   virtual ~SyntheticSection() = default;
   virtual void writeTo(uint8_t *Buf) = 0;
   virtual size_t getSize() const = 0;
+  // Finalize is split up into 3 parts to accommodate Thunks, early finalize
+  // should do as much as possible including finalizing the section size
+  virtual void earlyFinalize() {}
+  // If the size calculation needs to be updated during Thunk creation
+  virtual void updateAllocSize() {}
+  // Runs after all content has been added, must not alter section size
   virtual void finalize() {}
   virtual bool empty() const { return false; }
 
@@ -66,7 +72,7 @@
   GotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
-  void finalize() override;
+  void earlyFinalize() override;
   bool empty() const override;
 
   void addEntry(SymbolBody &Sym);
@@ -128,7 +134,8 @@
   MipsGotSection();
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
-  void finalize() override;
+  void earlyFinalize() override;
+  void updateAllocSize() override;
   bool empty() const override;
   void addEntry(SymbolBody &Sym, int64_t Addend, RelExpr Expr);
   bool addDynTlsEntry(SymbolBody &Sym);
@@ -336,6 +343,7 @@
 
 public:
   DynamicSection();
+  void earlyFinalize() override;
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return Size; }
@@ -382,6 +390,7 @@
   typedef typename ELFT::uint uintX_t;
   SymbolTableSection(StringTableSection<ELFT> &StrTabSec);
 
+  void earlyFinalize() override;
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return getNumSymbols() * sizeof(Elf_Sym); }
@@ -417,6 +426,7 @@
 
 public:
   GnuHashTableSection();
+  void earlyFinalize() override;
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
@@ -453,6 +463,7 @@
 
 public:
   HashTableSection();
+  void earlyFinalize() override;
   void finalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return this->Size; }
@@ -495,7 +506,7 @@
 
 public:
   GdbIndexSection();
-  void finalize() override;
+  void earlyFinalize() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   bool empty() const override;
@@ -571,6 +582,7 @@
 
 public:
   VersionDefinitionSection();
+  void earlyFinalize() override;
   void finalize() override;
   size_t getSize() const override;
   void writeTo(uint8_t *Buf) override;
@@ -639,7 +651,7 @@
                         uintX_t Alignment);
   void addSection(MergeInputSection<ELFT> *MS);
   void writeTo(uint8_t *Buf) override;
-  void finalize() override;
+  void earlyFinalize() override;
   bool shouldTailMerge() const;
   size_t getSize() const override;
 
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -441,7 +441,7 @@
   return B.GlobalDynIndex * sizeof(uintX_t);
 }
 
-template <class ELFT> void GotSection<ELFT>::finalize() {
+template <class ELFT> void GotSection<ELFT>::earlyFinalize() {
   Size = NumEntries * sizeof(uintX_t);
 }
 
@@ -619,7 +619,11 @@
          LocalEntries32.size();
 }
 
-template <class ELFT> void MipsGotSection<ELFT>::finalize() {
+template <class ELFT> void MipsGotSection<ELFT>::earlyFinalize() {
+  updateAllocSize();
+}
+
+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
@@ -858,11 +862,7 @@
 }
 
 // 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> void DynamicSection<ELFT>::earlyFinalize() {
   if (In<ELFT>::RelaDyn->OutSec->Size > 0) {
     bool IsRela = Config->Rela;
     add({IsRela ? DT_RELA : DT_REL, In<ELFT>::RelaDyn});
@@ -941,13 +941,17 @@
       add({DT_MIPS_RLD_MAP, In<ELFT>::MipsRldMap});
   }
 
-  this->OutSec->Entsize = this->Entsize;
-  this->OutSec->Link = this->Link;
-
   // +1 for DT_NULL
   this->Size = (Entries.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;
+  this->OutSec->Entsize = this->Entsize;
+  this->OutSec->Link = this->Link;
+}
+
 template <class ELFT> void DynamicSection<ELFT>::writeTo(uint8_t *Buf) {
   auto *P = reinterpret_cast<Elf_Dyn *>(Buf);
 
@@ -1083,38 +1087,15 @@
   return L->GotIndex < R->GotIndex;
 }
 
-template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
-  this->OutSec->Link = this->Link = StrTabSec.OutSec->SectionIndex;
-  this->OutSec->Entsize = this->Entsize;
-
-  if (!StrTabSec.isDynamic()) {
-    // All explictly added STB_LOCAL symbols without a Symbol are first
-    auto It = std::stable_partition(
-        Symbols.begin(), Symbols.end(),
-        [](const SymbolTableEntry &S) { return S.Symbol->isLocal(); });
-    NumLocals = It - Symbols.begin();
-  }
-  this->OutSec->Info = this->Info = 1 + NumLocals;
-
-  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>::earlyFinalize() {
+  if (!StrTabSec.isDynamic())
     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);
@@ -1124,6 +1105,35 @@
     S.Symbol->DynsymIndex = ++I;
 }
 
+template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
+  this->OutSec->Link = this->Link = StrTabSec.OutSec->SectionIndex;
+  this->OutSec->Entsize = this->Entsize;
+
+  if (StrTabSec.isDynamic()) {
+    this->OutSec->Info = this->Info = 1;
+    return;
+  }
+  // All explictly added STB_LOCAL symbols without a Symbol are first
+  auto It = std::stable_partition(
+      Symbols.begin(), Symbols.end(),
+      [](const SymbolTableEntry &S) { return S.Symbol->isLocal(); });
+  NumLocals = It - Symbols.begin();
+  this->OutSec->Info = this->Info = 1 + NumLocals;
+
+  if (Config->Relocatable)
+    return;
+
+  auto GlobBegin = Symbols.begin() + NumLocals;
+  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());
+  return;
+}
+
 template <class ELFT> void SymbolTableSection<ELFT>::addGlobal(SymbolBody *B) {
   Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
 }
@@ -1303,21 +1313,23 @@
   return NextPowerOf2((NumHashed - 1) / sizeof(Elf_Off));
 }
 
-template <class ELFT> void GnuHashTableSection<ELFT>::finalize() {
+template <class ELFT> void GnuHashTableSection<ELFT>::earlyFinalize() {
   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() {
+  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 +1393,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 +1428,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>::earlyFinalize() {
   unsigned NumEntries = 2;                            // nbucket and nchain.
   NumEntries += In<ELFT>::DynSymTab->getNumSymbols(); // The chain entries.
 
@@ -1430,6 +1439,11 @@
   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;
+}
+
 template <class ELFT> void HashTableSection<ELFT>::writeTo(uint8_t *Buf) {
   unsigned NumSymbols = In<ELFT>::DynSymTab->getNumSymbols();
   auto *P = reinterpret_cast<Elf_Word *>(Buf);
@@ -1563,7 +1577,7 @@
   }
 }
 
-template <class ELFT> void GdbIndexSection<ELFT>::finalize() {
+template <class ELFT> void GdbIndexSection<ELFT>::earlyFinalize() {
   if (Finalized)
     return;
   Finalized = true;
@@ -1588,7 +1602,7 @@
 }
 
 template <class ELFT> size_t GdbIndexSection<ELFT>::getSize() const {
-  const_cast<GdbIndexSection<ELFT> *>(this)->finalize();
+  const_cast<GdbIndexSection<ELFT> *>(this)->earlyFinalize();
   return StringPoolOffset + StringPool.getSize();
 }
 
@@ -1710,11 +1724,14 @@
   return Config->OutputFile;
 }
 
-template <class ELFT> void VersionDefinitionSection<ELFT>::finalize() {
+template <class ELFT> void VersionDefinitionSection<ELFT>::earlyFinalize() {
+  // 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() {
   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
@@ -1927,7 +1944,7 @@
   Builder.finalizeInOrder();
 }
 
-template <class ELFT> void MergeSyntheticSection<ELFT>::finalize() {
+template <class ELFT> void MergeSyntheticSection<ELFT>::earlyFinalize() {
   if (Finalized)
     return;
   Finalized = true;
@@ -1939,7 +1956,7 @@
 
 template <class ELFT> size_t MergeSyntheticSection<ELFT>::getSize() const {
   // We should finalize string builder to know the size.
-  const_cast<MergeSyntheticSection<ELFT> *>(this)->finalize();
+  const_cast<MergeSyntheticSection<ELFT> *>(this)->earlyFinalize();
   return Builder.getSize();
 }
 
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -1029,10 +1029,11 @@
 
 template <class ELFT>
 static void
-finalizeSynthetic(const std::vector<SyntheticSection<ELFT> *> &Sections) {
+applySynthetic(const std::vector<SyntheticSection<ELFT> *> &Sections,
+               std::function<void(SyntheticSection<ELFT> *)> Fn) {
   for (SyntheticSection<ELFT> *SS : Sections)
     if (SS && SS->OutSec && !SS->empty()) {
-      SS->finalize();
+      Fn(SS);
       SS->OutSec->Size = 0;
       SS->OutSec->assignOffsets();
     }
@@ -1109,10 +1110,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))
@@ -1153,11 +1154,35 @@
     fixHeaders();
   }
 
+  // Dynamic section must be the last one in this list and dynamic
+  // symbol table section (DynSymTab) must be the first one.
+  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};
+  // Perform as much Finalization as we can prior to ThunkCreation
+  applySynthetic<ELFT>(Synthetics,
+                       [](SyntheticSection<ELFT> *SS) { SS->earlyFinalize(); });
+
   // 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
+    if (createThunks<ELFT>(OutputSections))
+      applySynthetic<ELFT>(Synthetics, [](SyntheticSection<ELFT> *SS) {
+        SS->updateAllocSize();
+      });
+  }
 
   // Fill other section headers. The dynamic table is finalized
   // at the end because some tags like RELSZ depend on result
@@ -1165,17 +1190,8 @@
   for (OutputSectionBase *Sec : OutputSections)
     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});
+  applySynthetic<ELFT>(Synthetics,
+                       [](SyntheticSection<ELFT> *SS) { SS->finalize(); });
 }
 
 template <class ELFT> void Writer<ELFT>::addPredefinedSections() {