Index: ELF/InputFiles.cpp
===================================================================
--- ELF/InputFiles.cpp
+++ ELF/InputFiles.cpp
@@ -163,14 +163,6 @@
   if (Config->Optimize == 0)
     return false;
 
-  // We don't merge if linker script has SECTIONS command. When script
-  // do layout it can merge several sections with different attributes
-  // into single output sections. We currently do not support adding
-  // mergeable input sections to regular output ones as well as adding
-  // regular input sections to mergeable output.
-  if (ScriptConfig->HasContents)
-    return false;
-
   // A mergeable section with size 0 is useless because they don't have
   // any data to merge. A mergeable string section with size 0 can be
   // argued as invalid because it doesn't end with a null character.
Index: ELF/InputSection.h
===================================================================
--- ELF/InputSection.h
+++ ELF/InputSection.h
@@ -136,6 +136,8 @@
   static bool classof(const InputSectionBase<ELFT> *S);
   void splitIntoPieces();
 
+  void writeTo(uint8_t *Buf);
+
   // Mark the piece at a given offset live. Used by GC.
   void markLiveAt(uintX_t Offset) { LiveOffsets.insert(Offset); }
 
@@ -143,7 +145,7 @@
   // in the output section.
   uintX_t getOffset(uintX_t Offset) const;
 
-  void finalizePieces();
+  uintX_t finalizePieces(uintX_t Offset = (uintX_t )-1);
 
   // Splittable sections are handled as a sequence of data
   // rather than a single large blob of data.
@@ -157,7 +159,6 @@
   std::vector<SectionPiece> splitStrings(ArrayRef<uint8_t> A, size_t Size);
   std::vector<SectionPiece> splitNonStrings(ArrayRef<uint8_t> A, size_t Size);
 
-  llvm::DenseMap<uintX_t, uintX_t> OffsetMap;
   llvm::DenseSet<uintX_t> LiveOffsets;
 };
 
Index: ELF/InputSection.cpp
===================================================================
--- ELF/InputSection.cpp
+++ ELF/InputSection.cpp
@@ -620,20 +620,40 @@
 
 // Create a map from input offsets to output offsets for all section pieces.
 // It is called after finalize().
-template <class ELFT> void  MergeInputSection<ELFT>::finalizePieces() {
+template <class ELFT>
+typename ELFT::uint MergeInputSection<ELFT>::finalizePieces(uintX_t Offset) {
   OffsetMap.grow(this->Pieces.size());
+  uintX_t Size = 0;
   for (SectionPiece &Piece : this->Pieces) {
     if (!Piece.Live)
       continue;
+
+    // Offsets of tail-merged strings are computed lazily.
+    // The other case is when using linkerscript and have combination
+    // of mergeable and non-mergeable input sections in regular output section.
     if (Piece.OutputOff == size_t(-1)) {
-      // Offsets of tail-merged strings are computed lazily.
-      auto *OutSec = static_cast<MergeOutputSection<ELFT> *>(this->OutSec);
       ArrayRef<uint8_t> D = Piece.data();
       StringRef S((const char *)D.data(), D.size());
-      Piece.OutputOff = OutSec->getOffset(S);
+      uintX_t Off;
+      if (Offset == (uintX_t)-1)
+        Off = static_cast<MergeOutputSection<ELFT> *>(this->OutSec)->getOffset(S);
+      else
+        Off = Offset + Size;
+      Piece.OutputOff = Off;
+      Size += Piece.size();
     }
     OffsetMap[Piece.InputOff] = Piece.OutputOff;
   }
+  return Size;
+}
+
+template <class ELFT> void MergeInputSection<ELFT>::writeTo(uint8_t *Buf) {
+  for (SectionPiece &Piece : Pieces) {
+    if (Piece.OutputOff == (uintX_t)-1)
+      continue;
+    ArrayRef<uint8_t> Data = Piece.data();
+    memcpy(Buf + Piece.OutputOff, Data.data(), Data.size());
+  }
 }
 
 template <class ELFT>
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();
@@ -165,6 +165,10 @@
   std::vector<InputSectionBase<ELFT> *>
   createInputSectionList(OutputSectionCommand &Cmd);
 
+  std::pair<OutputSectionBase<ELFT> *, bool>
+  createOutputSection(InputSectionBase<ELFT> *C, StringRef Name,
+                      bool AllowMergeable);
+
   // "ScriptConfig" is a bit too long, so define a short name for it.
   ScriptConfiguration &Opt = *ScriptConfig;
 
@@ -174,6 +178,8 @@
 
   llvm::SpecificBumpPtrAllocator<LayoutInputSection<ELFT>> LAlloc;
 
+  std::vector<std::unique_ptr<OutputSectionBase<ELFT>>> OwningSections;
+
   uintX_t Dot;
 };
 
Index: ELF/LinkerScript.cpp
===================================================================
--- ELF/LinkerScript.cpp
+++ ELF/LinkerScript.cpp
@@ -259,7 +259,51 @@
 }
 
 template <class ELFT>
-void LinkerScript<ELFT>::createSections(OutputSectionFactory<ELFT> &Factory) {
+std::pair<OutputSectionBase<ELFT> *, bool>
+LinkerScript<ELFT>::createOutputSection(InputSectionBase<ELFT> *C,
+                                        StringRef Name, bool AllowMergeable) {
+  typedef typename ELFT::Shdr Elf_Shdr;
+
+  OutputSectionBase<ELFT> *Sec = nullptr;
+  for (std::unique_ptr<OutputSectionBase<ELFT>> &S : OwningSections) {
+    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;
+  unsigned Kind = C->SectionKind;
+  if (Kind == InputSectionBase<ELFT>::Merge) {
+    if (!AllowMergeable)
+      Kind = InputSectionBase<ELFT>::Regular;
+    Alignment = std::max(H->sh_addralign, H->sh_entsize);
+  }
+  uint32_t Type = H->sh_type;
+
+  bool IsNew;
+  std::tie(Sec, IsNew) =
+      allocSection<ELFT>(Kind, Name, Flags, Alignment, Type);
+  if (IsNew)
+    OwningSections.emplace_back(Sec);
+  return {Sec, IsNew};
+}
+
+template <class ELFT>
+static bool hasIncompatibles(InputSectionBase<ELFT> *Head,
+                             std::vector<InputSectionBase<ELFT> *> &Vec) {
+  uint64_t Flags = Head->getSectionHdr()->sh_flags;
+  for (InputSectionBase<ELFT> *S : Vec) {
+    if (isa<LayoutInputSection<ELFT>>(S))
+      continue;
+    if ((Flags & SHF_MERGE) != (S->getSectionHdr()->sh_flags & SHF_MERGE))
+      return true;
+  }
+  return false;
+}
+
+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))
@@ -279,8 +323,12 @@
         continue;
 
       OutputSectionBase<ELFT> *OutSec;
+      bool AllowMergeable = !hasIncompatibles(Head, V);
+      if (!AllowMergeable)
+        warning("SHF_MERGE flags will be ignored for " + Cmd->Name);
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(Head, Cmd->Name);
+      std::tie(OutSec, IsNew) =
+          createOutputSection(Head, Cmd->Name, AllowMergeable);
       if (IsNew)
         OutputSections->push_back(OutSec);
 
@@ -302,7 +350,8 @@
         continue;
       OutputSectionBase<ELFT> *OutSec;
       bool IsNew;
-      std::tie(OutSec, IsNew) = Factory.create(S, getOutputSectionName(S));
+      std::tie(OutSec, IsNew) =
+          createOutputSection(S, getOutputSectionName(S), true);
       if (IsNew)
         OutputSections->push_back(OutSec);
       OutSec->addSection(S);
@@ -320,8 +369,8 @@
   typedef typename ELFT::uint uintX_t;
   uintX_t Off = 0;
 
-  for (InputSection<ELFT> *I : OutSec->Sections) {
-    if (auto *L = dyn_cast<LayoutInputSection<ELFT>>(I)) {
+  for (InputSectionBase<ELFT> *B : OutSec->Sections) {
+    if (auto *L = dyn_cast<LayoutInputSection<ELFT>>(B)) {
       uintX_t Value = L->Cmd->Expression(Sec->getVA() + Off) - Sec->getVA();
       if (L->Cmd->Name == ".") {
         Off = Value;
@@ -332,10 +381,12 @@
         Sym->Section = OutSec;
         Sym->Value = Value;
       }
-    } else {
+    } else if (auto *I = dyn_cast<InputSection<ELFT>>(B)) {
       Off = alignTo(Off, I->Alignment);
       I->OutSecOff = Off;
       Off += I->getSize();
+    } else {
+      Off += dyn_cast<MergeInputSection<ELFT>>(B)->finalizePieces(Off);
     }
     // Update section size inside for-loop, so that SIZEOF
     // works correctly in the case below:
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.
@@ -403,7 +409,7 @@
   void assignOffsets() override;
   typename Base::Kind getKind() const override { return Base::Regular; }
   static bool classof(const Base *B) { return B->getKind() == Base::Regular; }
-  std::vector<InputSection<ELFT> *> Sections;
+  std::vector<InputSectionBase<ELFT> *> Sections;
 };
 
 template <class ELFT>
Index: ELF/OutputSections.cpp
===================================================================
--- ELF/OutputSections.cpp
+++ ELF/OutputSections.cpp
@@ -835,14 +835,14 @@
   this->Header.sh_link = Out<ELFT>::SymTab->SectionIndex;
   // sh_info for SHT_REL[A] sections should contain the section header index of
   // the section to which the relocation applies.
-  InputSectionBase<ELFT> *S = Sections[0]->getRelocatedSection();
+  InputSectionBase<ELFT> *S =
+      dyn_cast<InputSection<ELFT>>(Sections[0])->getRelocatedSection();
   this->Header.sh_info = S->OutSec->SectionIndex;
 }
 
 template <class ELFT>
-void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *C) {
-  assert(C->Live);
-  auto *S = cast<InputSection<ELFT>>(C);
+void OutputSection<ELFT>::addSection(InputSectionBase<ELFT> *S) {
+  assert(S->Live);
   Sections.push_back(S);
   S->OutSec = this;
   this->updateAlignment(S->Alignment);
@@ -865,7 +865,8 @@
 // and scan relocations to setup sections' offsets.
 template <class ELFT> void OutputSection<ELFT>::assignOffsets() {
   uintX_t Off = this->Header.sh_size;
-  for (InputSection<ELFT> *S : Sections) {
+  for (InputSectionBase<ELFT> *C : Sections) {
+    InputSection<ELFT> *S = dyn_cast<InputSection<ELFT>>(C);
     Off = alignTo(Off, S->Alignment);
     S->OutSecOff = Off;
     Off += S->getSize();
@@ -885,8 +886,10 @@
   auto Comp = [](const Pair &A, const Pair &B) { return A.first < B.first; };
 
   std::vector<Pair> V;
-  for (InputSection<ELFT> *S : Sections)
+  for (InputSectionBase<ELFT> *B : Sections) {
+    auto S = dyn_cast<InputSection<ELFT>>(B);
     V.push_back({getPriority(S->getSectionName()), S});
+  }
   std::stable_sort(V.begin(), V.end(), Comp);
   Sections.clear();
   for (Pair &P : V)
@@ -925,8 +928,10 @@
 // are too many real-world use cases of .ctors, so we had no choice to
 // support that with this rather ad-hoc semantics.
 template <class ELFT>
-static bool compCtors(const InputSection<ELFT> *A,
-                      const InputSection<ELFT> *B) {
+static bool compCtors(const InputSectionBase<ELFT> *L,
+                      const InputSectionBase<ELFT> *R) {
+  auto A = dyn_cast<InputSection<ELFT>>(L);
+  auto B = dyn_cast<InputSection<ELFT>>(R);
   bool BeginA = isCrtbegin(A->getFile()->getName());
   bool BeginB = isCrtbegin(B->getFile()->getName());
   if (BeginA != BeginB)
@@ -961,15 +966,22 @@
 }
 
 template <class ELFT> void OutputSection<ELFT>::writeTo(uint8_t *Buf) {
+  auto WriteOne = [&](InputSectionBase<ELFT> *B) {
+    if (auto C = dyn_cast<InputSection<ELFT>>(B))
+      C->writeTo(Buf);
+    else
+      dyn_cast<MergeInputSection<ELFT>>(B)->writeTo(Buf);
+  };
+
   ArrayRef<uint8_t> Filler = Script<ELFT>::X->getFiller(this->Name);
   if (!Filler.empty())
     fill(Buf, this->getSize(), Filler);
   if (Config->Threads) {
     parallel_for_each(Sections.begin(), Sections.end(),
-                      [=](InputSection<ELFT> *C) { C->writeTo(Buf); });
+                      [=](InputSectionBase<ELFT> *B) { WriteOne(B); });
   } else {
-    for (InputSection<ELFT> *C : Sections)
-      C->writeTo(Buf);
+    for (InputSectionBase<ELFT> *B : Sections)
+      WriteOne(B);
   }
 }
 
@@ -1784,22 +1796,17 @@
 
 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) {
+  OutputSectionBase<ELFT> *Sec;
+  switch (Kind) {
   case InputSectionBase<ELFT>::Regular:
-    Sec = new OutputSection<ELFT>(Key.Name, Key.Type, Key.Flags);
+    Sec = new OutputSection<ELFT>(Name, Type, Flags);
     break;
   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);
+    Sec = new MergeOutputSection<ELFT>(Name, Type, Flags, Alignment);
     break;
   case InputSectionBase<ELFT>::MipsReginfo:
     Sec = new MipsReginfoOutputSection<ELFT>();
@@ -1813,11 +1820,27 @@
   case InputSectionBase<ELFT>::Layout:
     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>
 SectionKey<ELFT::Is64Bits>
 OutputSectionFactory<ELFT>::createKey(InputSectionBase<ELFT> *C,
                                       StringRef OutsecName) {
@@ -2005,3 +2028,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
@@ -248,7 +248,7 @@
 
   Script<ELFT>::X->OutputSections = &OutputSections;
   if (ScriptConfig->HasContents)
-    Script<ELFT>::X->createSections(Factory);
+    Script<ELFT>::X->createSections();
   else
     createSections();
 
Index: test/ELF/linkerscript/linkerscript-mix-sections-gc.s
===================================================================
--- test/ELF/linkerscript/linkerscript-mix-sections-gc.s
+++ test/ELF/linkerscript/linkerscript-mix-sections-gc.s
@@ -0,0 +1,35 @@
+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { .foo : { *(.foo.*) } }" > %t.script
+# RUN: ld.lld --gc-sections -o %t1 --script %t.script %t
+# RUN: llvm-objdump -s %t1 | FileCheck %s
+# CHECK:      Contents of section .foo:
+# CHECK-NEXT:  {{.*}} fzzzzz.
+
+.text
+.globl _start
+_start:
+ movl $s0, %eax
+ movl $s2, %eax
+
+.hidden s0
+.type s0,@object
+.section .foo.0,"aM",@progbits,1
+.globl s0
+s0:
+.asciz "foo"
+
+.hidden s1
+.type s1,@object
+.section .foo.1,"aMS",@progbits,1
+.globl s1
+s1:
+.asciz "boo"
+
+.hidden s2
+.type s2,@object
+.section .foo.2,"a"
+.globl s2
+s2:
+.asciz "zzzzz"
Index: test/ELF/linkerscript/linkerscript-mix-sections.s
===================================================================
--- test/ELF/linkerscript/linkerscript-mix-sections.s
+++ test/ELF/linkerscript/linkerscript-mix-sections.s
@@ -0,0 +1,34 @@
+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+# RUN: echo "SECTIONS { .foo : { *(.foo.*) } }" > %t.script
+# RUN: ld.lld -o %t1 --script %t.script %t
+# RUN: llvm-objdump -s %t1 | FileCheck %s
+# CHECK:      Contents of section .foo:
+# CHECK-NEXT:  {{.*}} foo.boo.zzzzz.
+
+.text
+.globl _start
+_start:
+ nop
+
+.hidden s0
+.type s0,@object
+.section .foo.0,"aM",@progbits,1
+.globl s0
+s0:
+.asciz "foo"
+
+.hidden s1
+.type s1,@object
+.section .foo.1,"aMS",@progbits,1
+.globl s1
+s1:
+.asciz "boo"
+
+.hidden s2
+.type s2,@object
+.section .foo.2,"a"
+.globl s2
+s2:
+.asciz "zzzzz"