Index: ELF/LinkerScript.h
===================================================================
--- ELF/LinkerScript.h
+++ ELF/LinkerScript.h
@@ -140,7 +140,7 @@
 public:
   LinkerScript();
   ~LinkerScript();
-  void createSections(OutputSectionFactory<ELFT> &Factory);
+  void createSections();
 
   std::vector<PhdrEntry<ELFT>> createPhdrs();
   bool ignoreInterpSection();
Index: ELF/LinkerScript.cpp
===================================================================
--- ELF/LinkerScript.cpp
+++ ELF/LinkerScript.cpp
@@ -259,7 +259,34 @@
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
+static std::pair<OutputSectionBase<ELFT> *, bool>
+createOutputSection(InputSectionBase<ELFT> *C, StringRef Name) {
+  typedef typename ELFT::Shdr Elf_Shdr;
+  typedef typename ELFT::uint uintX_t;
+
+  for (std::unique_ptr<OutputSectionBase<ELFT>> &S : Out<ELFT>::Pool) {
+    if (S->getName() == Name)
+      return {S.get(), false};
+  }
+
+  const Elf_Shdr *H = C->getSectionHdr();
+  uintX_t Flags = H->sh_flags & ~SHF_GROUP & ~SHF_COMPRESSED;
+  uintX_t Alignment = 0;
+  if (isa<MergeInputSection<ELFT>>(C))
+    Alignment = std::max(H->sh_addralign, H->sh_entsize);
+  uint32_t Type = H->sh_type;
+
+  bool IsNew;
+  OutputSectionBase<ELFT> *Sec = nullptr;
+  std::tie(Sec, IsNew) =
+      allocSection<ELFT>(C->SectionKind, Name, Flags, Alignment, Type);
+  if (IsNew)
+    Out<ELFT>::Pool.emplace_back(Sec);
+  return {Sec, IsNew};
+}
+
+template <class ELFT>
+void LinkerScript<ELFT>::createSections() {
   for (const std::unique_ptr<BaseCommand> &Base1 : Opt.Commands) {
     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base1.get())) {
       if (shouldDefine<ELFT>(Cmd))
@@ -280,7 +307,7 @@
 
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(Head, Cmd->Name);
+      std::tie(OutSec, IsNew) = createOutputSection(Head, Cmd->Name);
       if (IsNew)
         OutputSections->push_back(OutSec);
 
@@ -302,7 +329,7 @@
         continue;
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
+      std::tie(OutSec, IsNew) = createOutputSection(S, getOutputSectionName(S));
       if (IsNew)
         OutputSections->push_back(OutSec);
       OutSec->addSection(S);
Index: ELF/OutputSections.h
===================================================================
--- ELF/OutputSections.h
+++ ELF/OutputSections.h
@@ -34,11 +34,17 @@
 template <class ELFT> class MergeInputSection;
 template <class ELFT> class MipsReginfoInputSection;
 template <class ELFT> class OutputSection;
+template <class ELFT> class OutputSectionBase;
 template <class ELFT> class ObjectFile;
 template <class ELFT> class SharedFile;
 template <class ELFT> class SharedSymbol;
 template <class ELFT> class DefinedRegular;
 
+template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+             typename ELFT::uint Alignment, uint32_t Type);
+
 // This represents a section in an output file.
 // Different sub classes represent different types of sections. Some contain
 // input sections, others are created by the linker.
Index: ELF/OutputSections.cpp
===================================================================
--- ELF/OutputSections.cpp
+++ ELF/OutputSections.cpp
@@ -1790,37 +1790,41 @@
 
 template <class ELFT>
 std::pair<OutputSectionBase<ELFT> *, bool>
-OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
-                                   StringRef OutsecName) {
-  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
-  OutputSectionBase<ELFT> *&Sec = Map[Key];
-  if (Sec)
-    return {Sec, false};
-
-  switch (C->SectionKind) {
+elf::allocSection(unsigned Kind, StringRef Name, typename ELFT::uint Flags,
+                  typename ELFT::uint Alignment, uint32_t Type) {
+  switch (Kind) {
   case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
-    break;
+    return {new OutputSection<ELFT>(Name, Type, Flags), true};
   case InputSectionBase<ELFT>::EHFrame:
     return {Out<ELFT>::EhFrame, false};
   case InputSectionBase<ELFT>::Merge:
-    Sec = new MergeOutputSection<ELFT>(Key.Name, Key.Type, Key.Flags,
-                                       Key.Alignment);
-    break;
+    return {new MergeOutputSection<ELFT>(Name, Type, Flags, Alignment), true};
   case InputSectionBase<ELFT>::MipsReginfo:
-    Sec = new MipsReginfoOutputSection<ELFT>();
-    break;
+    return {new MipsReginfoOutputSection<ELFT>(), true};
   case InputSectionBase<ELFT>::MipsOptions:
-    Sec = new MipsOptionsOutputSection<ELFT>();
-    break;
+    return {new MipsOptionsOutputSection<ELFT>(), true};
   case InputSectionBase<ELFT>::MipsAbiFlags:
-    Sec = new MipsAbiFlagsOutputSection<ELFT>();
-    break;
-  case InputSectionBase<ELFT>::Layout:
+    return {new MipsAbiFlagsOutputSection<ELFT>(), true};
+  default:
     llvm_unreachable("Invalid section type");
   }
-  Out<ELFT>::Pool.emplace_back(Sec);
-  return {Sec, true};
+}
+
+template <class ELFT>
+std::pair<OutputSectionBase<ELFT> *, bool>
+OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
+                                   StringRef OutsecName) {
+  SectionKey<ELFT::Is64Bits> Key = createKey(C, OutsecName);
+  OutputSectionBase<ELFT> *&Sec = Map[Key];
+  if (Sec)
+    return {Sec, false};
+
+  bool Allocated;
+  std::tie(Sec, Allocated) = allocSection<ELFT>(
+      C->SectionKind, Key.Name, Key.Flags, Key.Alignment, Key.Type);
+  if (Allocated)
+    Out<ELFT>::Pool.emplace_back(Sec);
+  return {Sec, Allocated};
 }
 
 template <class ELFT>
@@ -2016,3 +2020,16 @@
 template class OutputSectionFactory<ELF64BE>;
 }
 }
+
+template std::pair<OutputSectionBase<ELF32LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32LE::uint Flags,
+                  ELF32LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF32BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF32BE::uint Flags,
+                  ELF32BE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64LE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64LE::uint Flags,
+                  ELF64LE::uint Alignment, uint32_t Type);
+template std::pair<OutputSectionBase<ELF64BE> *, bool>
+elf::allocSection(unsigned Kind, StringRef Name, ELF64BE::uint Flags,
+                  ELF64BE::uint Alignment, uint32_t Type);
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -252,7 +252,7 @@
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasContents)
-    Script<ELFT>::X->createSections(Factory);
+    Script<ELFT>::X->createSections();
   else
     createSections();