Index: ELF/Relocations.cpp
===================================================================
--- ELF/Relocations.cpp
+++ ELF/Relocations.cpp
@@ -479,8 +479,8 @@
   // See if this symbol is in a read-only segment. If so, preserve the symbol's
   // memory protection by reserving space in the .bss.rel.ro section.
   bool IsReadOnly = isReadOnly<ELFT>(SS);
-  BssRelSection<ELFT> *RelSec = IsReadOnly ? In<ELFT>::BssRelRo : In<ELFT>::Bss;
-  uintX_t Off = RelSec->addCopyRelocation(SS->getAlignment<ELFT>(), SymSize);
+  BssSection<ELFT> *RelSec = IsReadOnly ? In<ELFT>::BssRelRo : In<ELFT>::Bss;
+  uintX_t Off = RelSec->reserveSpace(SS->getAlignment<ELFT>(), SymSize);
 
   // Look through the DSO's dynamic symbol table for aliases and create a
   // dynamic symbol for each one. This causes the copy relocation to correctly
Index: ELF/SyntheticSections.h
===================================================================
--- ELF/SyntheticSections.h
+++ ELF/SyntheticSections.h
@@ -147,16 +147,17 @@
   uint8_t *HashBuf;
 };
 
-// Section used for storing copy relocations. We create two sections now,
-// .bss.rel.ro for RelRo case and .bss for regular case.
-template <class ELFT> class BssRelSection final : public SyntheticSection {
+// Section used for common symbols and storing copy relocations. We create
+// three sections now: ".bss.rel.ro", ".bss" for relro and regular copy
+// relocations and "COMMON" section for holding common symbols.
+template <class ELFT> class BssSection final : public SyntheticSection {
   typedef typename ELFT::uint uintX_t;
 
 public:
-  BssRelSection(bool RelRo);
+  BssSection(StringRef Name);
   void writeTo(uint8_t *) override {}
   bool empty() const override { return getSize() == 0; }
-  size_t addCopyRelocation(uintX_t AddrAlign, size_t Size);
+  size_t reserveSpace(uintX_t AddrAlign, size_t Size);
   size_t getSize() const override { return Size; }
   size_t Size;
 };
@@ -759,8 +760,8 @@
 template <class ELFT> struct In {
   static InputSection *ARMAttributes;
   static BuildIdSection<ELFT> *BuildId;
-  static BssRelSection<ELFT> *Bss;
-  static BssRelSection<ELFT> *BssRelRo;
+  static BssSection<ELFT> *Bss;
+  static BssSection<ELFT> *BssRelRo;
   static InputSection *Common;
   static DynamicSection<ELFT> *Dynamic;
   static StringTableSection<ELFT> *DynStrTab;
@@ -790,8 +791,8 @@
 };
 
 template <class ELFT> InputSection *In<ELFT>::ARMAttributes;
-template <class ELFT> BssRelSection<ELFT> *In<ELFT>::Bss;
-template <class ELFT> BssRelSection<ELFT> *In<ELFT>::BssRelRo;
+template <class ELFT> BssSection<ELFT> *In<ELFT>::Bss;
+template <class ELFT> BssSection<ELFT> *In<ELFT>::BssRelRo;
 template <class ELFT> BuildIdSection<ELFT> *In<ELFT>::BuildId;
 template <class ELFT> InputSection *In<ELFT>::Common;
 template <class ELFT> DynamicSection<ELFT> *In<ELFT>::Dynamic;
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -63,33 +63,21 @@
 
 // Find all common symbols and allocate space for them.
 template <class ELFT> InputSection *elf::createCommonSection() {
-  auto *Ret = make<InputSection>(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, 1,
-                                 ArrayRef<uint8_t>(), "COMMON");
-  Ret->Live = true;
-
   if (!Config->DefineCommon)
-    return Ret;
+    return nullptr;
 
   // Sort the common symbols by alignment as an heuristic to pack them better.
   std::vector<DefinedCommon *> Syms = getCommonSymbols<ELFT>();
+  if (Syms.empty())
+    return nullptr;
+
   std::stable_sort(Syms.begin(), Syms.end(),
                    [](const DefinedCommon *A, const DefinedCommon *B) {
                      return A->Alignment > B->Alignment;
                    });
-
-  // Assign offsets to symbols.
-  size_t Size = 0;
-  size_t Alignment = 1;
-  for (DefinedCommon *Sym : Syms) {
-    Alignment = std::max<size_t>(Alignment, Sym->Alignment);
-    Size = alignTo(Size, Sym->Alignment);
-
-    // Compute symbol offset relative to beginning of input section.
-    Sym->Offset = Size;
-    Size += Sym->Size;
-  }
-  Ret->Alignment = Alignment;
-  Ret->Data = makeArrayRef<uint8_t>(nullptr, Size);
+  BssSection<ELFT> *Ret = make<BssSection<ELFT>>("COMMON");
+  for (DefinedCommon *Sym : Syms)
+    Sym->Offset = Ret->reserveSpace(Sym->Alignment, Sym->Size);
   return Ret;
 }
 
@@ -377,15 +365,15 @@
 }
 
 template <class ELFT>
-BssRelSection<ELFT>::BssRelSection(bool RelRo)
-    : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, 0,
-                       RelRo ? ".bss.rel.ro" : ".bss"),
-      Size(0) {}
+BssSection<ELFT>::BssSection(StringRef Name)
+    : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_NOBITS, 0, Name), Size(0) {}
 
 template <class ELFT>
-size_t BssRelSection<ELFT>::addCopyRelocation(uintX_t AddrAlign, size_t Size) {
-  OutSec->updateAlignment(AddrAlign);
+size_t BssSection<ELFT>::reserveSpace(uintX_t AddrAlign, size_t Size) {
   this->Size = alignTo(this->Size, AddrAlign) + Size;
+  this->Alignment = std::max<size_t>(this->Alignment, AddrAlign);
+  if (OutSec)
+    OutSec->updateAlignment(AddrAlign);
   return this->Size - Size;
 }
 
@@ -2305,10 +2293,10 @@
 template class elf::BuildIdSection<ELF64LE>;
 template class elf::BuildIdSection<ELF64BE>;
 
-template class elf::BssRelSection<ELF32LE>;
-template class elf::BssRelSection<ELF32BE>;
-template class elf::BssRelSection<ELF64LE>;
-template class elf::BssRelSection<ELF64BE>;
+template class elf::BssSection<ELF32LE>;
+template class elf::BssSection<ELF32BE>;
+template class elf::BssSection<ELF64LE>;
+template class elf::BssSection<ELF64BE>;
 
 template class elf::GotSection<ELF32LE>;
 template class elf::GotSection<ELF32BE>;
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -340,15 +340,12 @@
     Add(In<ELFT>::BuildId);
   }
 
-  InputSection *Common = createCommonSection<ELFT>();
-  if (!Common->Data.empty()) {
-    In<ELFT>::Common = Common;
-    Add(Common);
-  }
+  if (In<ELFT>::Common = createCommonSection<ELFT>())
+    Add(In<ELFT>::Common);
 
-  In<ELFT>::Bss = make<BssRelSection<ELFT>>(false /*RelRo*/);
+  In<ELFT>::Bss = make<BssSection<ELFT>>(".bss");
   Add(In<ELFT>::Bss);
-  In<ELFT>::BssRelRo = make<BssRelSection<ELFT>>(true /*RelRo*/);
+  In<ELFT>::BssRelRo = make<BssSection<ELFT>>(".bss.rel.ro");
   Add(In<ELFT>::BssRelRo);
 
   // Add MIPS-specific sections.