Index: ELF/SymbolTable.h
===================================================================
--- ELF/SymbolTable.h
+++ ELF/SymbolTable.h
@@ -43,6 +43,7 @@
   void addCombinedLTOObject();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
+  ArrayRef<SymbolBody *> getSyntheticLocals() const { return SyntheticLocals; }
   ArrayRef<ObjectFile<ELFT> *> getObjectFiles() const { return ObjectFiles; }
   ArrayRef<BinaryFile *> getBinaryFiles() const { return BinaryFiles; }
   ArrayRef<SharedFile<ELFT> *> getSharedFiles() const { return SharedFiles; }
@@ -64,6 +65,10 @@
 
   Symbol *addSynthetic(StringRef N, const OutputSectionBase *Section,
                        uintX_t Value, uint8_t StOther);
+  // For symbols with STB_LOCAL binding and non-unique symbol names
+  SymbolBody *addSyntheticLocal(StringRef Name, uint8_t StOther, uint8_t Type,
+                                uintX_t Value, uintX_t Size,
+                                InputSectionBase<ELFT> *Section);
 
   void addShared(SharedFile<ELFT> *F, StringRef Name, const Elf_Sym &Sym,
                  const typename ELFT::Verdef *Verdef);
@@ -139,6 +144,9 @@
   // directive in version scripts.
   llvm::Optional<llvm::StringMap<std::vector<SymbolBody *>>> DemangledSyms;
 
+  // Symbols with STB_LOCAL binding defined in Synthetic Sections
+  std::vector<SymbolBody *> SyntheticLocals;
+
   // For LTO.
   std::unique_ptr<BitcodeCompiler> LTO;
 };
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -414,6 +414,18 @@
   return S;
 }
 
+// For non-unique local symbol names defined in Synthetic Sections
+template <typename ELFT>
+SymbolBody *
+SymbolTable<ELFT>::addSyntheticLocal(StringRef Name, uint8_t StOther,
+                                     uint8_t Type, uintX_t Value, uintX_t Size,
+                                     InputSectionBase<ELFT> *Section) {
+  auto S = new (BAlloc) DefinedRegular<ELFT>(
+      Name, /*IsLocal*/ true, StOther, Type, Value, Size, Section, nullptr);
+  SyntheticLocals.push_back(S);
+  return S;
+}
+
 template <typename ELFT>
 void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *F, StringRef Name,
                                   const Elf_Sym &Sym,
Index: ELF/SyntheticSections.h
===================================================================
--- ELF/SyntheticSections.h
+++ ELF/SyntheticSections.h
@@ -367,6 +367,7 @@
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override { return getNumSymbols() * sizeof(Elf_Sym); }
   void addSymbol(SymbolBody *Body);
+  void addSyntheticLocal(SymbolBody *Body);
   StringTableSection<ELFT> &getStrTabSec() const { return StrTabSec; }
   unsigned getNumSymbols() const { return NumLocals + Symbols.size() + 1; }
 
@@ -378,11 +379,15 @@
   StringTableSection<ELFT> &StrTabSec;
 
 private:
+  void writeLocalSymbol(Elf_Sym *ESym, const DefinedRegular<ELFT> &Body,
+                        size_t StrTabOffset);
   void writeLocalSymbols(uint8_t *&Buf);
   void writeGlobalSymbols(uint8_t *Buf);
 
   // A vector of symbols and their string table offsets.
   std::vector<SymbolTableEntry> Symbols;
+  // For local symbols defined in synthetic sections
+  std::vector<SymbolTableEntry> SyntheticLocals;
 };
 
 // Outputs GNU Hash section. For detailed explanation see:
Index: ELF/SyntheticSections.cpp
===================================================================
--- ELF/SyntheticSections.cpp
+++ ELF/SyntheticSections.cpp
@@ -1098,6 +1098,12 @@
   Symbols.push_back({B, StrTabSec.addString(B->getName(), false)});
 }
 
+template <class ELFT>
+void SymbolTableSection<ELFT>::addSyntheticLocal(SymbolBody *B) {
+  SyntheticLocals.push_back({B, StrTabSec.addString(B->getName())});
+  ++NumLocals;
+}
+
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   Buf += sizeof(Elf_Sym);
 
@@ -1110,6 +1116,24 @@
 }
 
 template <class ELFT>
+void SymbolTableSection<ELFT>::writeLocalSymbol(
+    Elf_Sym *ESym, const DefinedRegular<ELFT> &Body, size_t StrTabOffset) {
+  InputSectionBase<ELFT> *Section = Body.Section;
+
+  if (!Section) {
+    ESym->st_shndx = SHN_ABS;
+    ESym->st_value = Body.Value;
+  } else {
+    const OutputSectionBase *OutSec = Section->OutSec;
+    ESym->st_shndx = OutSec->SectionIndex;
+    ESym->st_value = OutSec->Addr + Section->getOffset(Body);
+  }
+  ESym->st_name = StrTabOffset;
+  ESym->st_size = Body.template getSize<ELFT>();
+  ESym->setBindingAndType(STB_LOCAL, Body.Type);
+}
+
+template <class ELFT>
 void SymbolTableSection<ELFT>::writeLocalSymbols(uint8_t *&Buf) {
   // Iterate over all input object files to copy their local symbols
   // to the output symbol table pointed by Buf.
@@ -1117,23 +1141,19 @@
     for (const std::pair<const DefinedRegular<ELFT> *, size_t> &P :
          File->KeptLocalSyms) {
       const DefinedRegular<ELFT> &Body = *P.first;
-      InputSectionBase<ELFT> *Section = Body.Section;
       auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
-
-      if (!Section) {
-        ESym->st_shndx = SHN_ABS;
-        ESym->st_value = Body.Value;
-      } else {
-        const OutputSectionBase *OutSec = Section->OutSec;
-        ESym->st_shndx = OutSec->SectionIndex;
-        ESym->st_value = OutSec->Addr + Section->getOffset(Body);
-      }
-      ESym->st_name = P.second;
-      ESym->st_size = Body.template getSize<ELFT>();
-      ESym->setBindingAndType(STB_LOCAL, Body.Type);
+      writeLocalSymbol(ESym, Body, P.second);
       Buf += sizeof(*ESym);
     }
   }
+  // Write Synthetic Locals
+  for (const SymbolTableEntry &S : SyntheticLocals) {
+    SymbolBody *Body = S.Symbol;
+    auto DR = dyn_cast<DefinedRegular<ELFT>>(Body);
+    auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
+    writeLocalSymbol(ESym, *DR, S.StrTabOffset);
+    Buf += sizeof(*ESym);
+  }
 }
 
 template <class ELFT>
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -1054,6 +1054,9 @@
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
+  for (SymbolBody *Body : Symtab<ELFT>::X->getSyntheticLocals())
+    if (In<ELFT>::SymTab && includeInSymtab<ELFT>(*Body))
+      In<ELFT>::SymTab->addSyntheticLocal(Body);
 
   // Do not proceed if there was an undefined symbol.
   if (ErrorCount)