Index: test/tools/llvm-objcopy/basic-copy.test
===================================================================
--- test/tools/llvm-objcopy/basic-copy.test
+++ test/tools/llvm-objcopy/basic-copy.test
@@ -22,11 +22,6 @@
 
 # CHECK: Type: SHT_NULL
 
-# CHECK:      Name: .shstrtab
-# CHECK-NEXT: Type: SHT_STRTAB
-# CHECK-NEXT: Flags [
-# CHECK-NEXT: ]
-
 # CHECK:      Name: .bss
 # CHECK-NEXT: Type: SHT_NOBITS
 # CHECK-NEXT: Flags [
@@ -45,3 +40,18 @@
 # CHECK-NEXT: Address:
 # CHECK-NEXT: Offset: [[OFFSET]]
 # CHECK-NEXT: Size: 4
+
+# CHECK:      Name: .symtab
+# CHECK-NEXT: Type: SHT_SYMTAB
+# CHECK-NEXT: Flags [
+# CHECK-NEXT: ]
+
+# CHECK:      Name: .strtab
+# CHECK-NEXT: Type: SHT_STRTAB
+# CHECK-NEXT: Flags [
+# CHECK-NEXT: ]
+
+# CHECK:      Name: .shstrtab
+# CHECK-NEXT: Type: SHT_STRTAB
+# CHECK-NEXT: Flags [
+# CHECK-NEXT: ]
Index: test/tools/llvm-objcopy/symbol-copy.test
===================================================================
--- /dev/null
+++ test/tools/llvm-objcopy/symbol-copy.test
@@ -0,0 +1,91 @@
+# RUN: yaml2obj %s > %t
+# RUN: llvm-objcopy %t %t2
+# RUN: llvm-readobj -symbols %t2 | FileCheck %s
+
+!ELF
+FileHeader:
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+Sections:
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x1000
+    AddressAlign:    0x0000000000000010
+    Content:         "0000000000000000"
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x2000
+    AddressAlign:    0x0000000000000010
+    Content:         "0000000000000000"
+Symbols:
+  Global:
+    - Name:     _start
+      Type:     STT_FUNC
+      Section:  .text
+      Value:    0x1000
+      Size:     4
+    - Name:     foo
+      Type:     STT_FUNC
+      Section:  .text
+      Section:  .text
+      Value:    0x1004
+    - Name:     bar
+      Type:     STT_OBJECT
+      Section:  .data
+      Value:    0x2000
+      Size:     4
+    - Name:     baz
+      Type:     STT_OBJECT
+      Section:  .data
+      Value:    0x2004
+      Size:     4
+
+#CHECK: Symbols [
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name:
+#CHECK-NEXT:    Value: 0x0
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Local
+#CHECK-NEXT:    Type: None
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: Undefined
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: _start
+#CHECK-NEXT:    Value: 0x1000
+#CHECK-NEXT:    Size: 4
+#CHECK-NEXT:    Binding: Global
+#CHECK-NEXT:    Type: Function
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .text
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: foo
+#CHECK-NEXT:    Value: 0x1004
+#CHECK-NEXT:    Size: 0
+#CHECK-NEXT:    Binding: Global
+#CHECK-NEXT:    Type: Function
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .text
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: bar
+#CHECK-NEXT:    Value: 0x2000
+#CHECK-NEXT:    Size: 4
+#CHECK-NEXT:    Binding: Global
+#CHECK-NEXT:    Type: Object
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .data
+#CHECK-NEXT:  }
+#CHECK-NEXT:  Symbol {
+#CHECK-NEXT:    Name: baz
+#CHECK-NEXT:    Value: 0x2004
+#CHECK-NEXT:    Size: 4
+#CHECK-NEXT:    Binding: Global
+#CHECK-NEXT:    Type: Object
+#CHECK-NEXT:    Other: 0
+#CHECK-NEXT:    Section: .data
Index: tools/llvm-objcopy/Object.h
===================================================================
--- tools/llvm-objcopy/Object.h
+++ tools/llvm-objcopy/Object.h
@@ -108,6 +108,36 @@
   }
 };
 
+struct Symbol {
+  uint8_t Binding;
+  SectionBase *DefinedIn;
+  uint32_t Index;
+  llvm::StringRef Name;
+  uint32_t NameIndex;
+  uint64_t Size;
+  uint8_t Type;
+  uint64_t Value;
+};
+// The symbol data changes from ELFT to ELFT so we need to template it. This
+// lets us implement writeSection
+template <class ELFT> class SymbolTableSection : public SectionBase {
+private:
+  std::vector<Symbol> FinalSymbols;
+  llvm::StringMap<Symbol> Symbols;
+  StringTableSection *SymbolNames;
+
+public:
+  void setStrTab(StringTableSection *StrTab) { SymbolNames = StrTab; }
+  void addSymbol(llvm::StringRef Name, uint8_t Bind, uint8_t Type,
+                 SectionBase *DefinedIn, uint64_t Value, uint64_t Sz);
+  void removeSymbol(llvm::StringRef);
+  void finalize() override;
+  void writeSection(llvm::FileOutputBuffer &) const override;
+  static bool classof(const SectionBase *S) {
+    return S->Type == llvm::ELF::SHT_SYMTAB;
+  }
+};
+
 template <class ELFT> class Object {
 private:
   typedef std::unique_ptr<SectionBase> SecPtr;
@@ -117,12 +147,15 @@
   typedef typename ELFT::Ehdr Elf_Ehdr;
   typedef typename ELFT::Phdr Elf_Phdr;
 
-  StringTableSection *SectionNames;
+  StringTableSection *SectionNames = nullptr;
+  SymbolTableSection<ELFT> *SymbolTable = nullptr;
   std::vector<SecPtr> Sections;
   std::vector<SegPtr> Segments;
 
   void sortSections();
   void assignOffsets();
+  SecPtr makeSection(const llvm::object::ELFFile<ELFT> &ElfFile,
+                     const Elf_Shdr &Shdr);
   void readProgramHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
   void readSectionHeaders(const llvm::object::ELFFile<ELFT> &ElfFile);
   void writeHeader(llvm::FileOutputBuffer &Out) const;
Index: tools/llvm-objcopy/Object.cpp
===================================================================
--- tools/llvm-objcopy/Object.cpp
+++ tools/llvm-objcopy/Object.cpp
@@ -76,6 +76,77 @@
   StrTabBuilder.write(Out.getBufferStart() + Offset);
 }
 
+template <class ELFT>
+void SymbolTableSection<ELFT>::addSymbol(StringRef Name, uint8_t Bind,
+                                         uint8_t Type, SectionBase *DefinedIn,
+                                         uint64_t Value, uint64_t Sz) {
+  Symbol Sym;
+  Sym.Name = Name;
+  Sym.Binding = Bind;
+  Sym.Type = Type;
+  Sym.DefinedIn = DefinedIn;
+  Sym.Value = Value;
+  Sym.Size = Sz;
+  Sym.Index = Symbols.size();
+  auto Res = Symbols.insert(std::make_pair(Name, Sym));
+  if (Res.second)
+    Size += sizeof(typename ELFT::Sym);
+}
+
+template <class ELFT>
+void SymbolTableSection<ELFT>::removeSymbol(StringRef Name) {
+  auto Iter = Symbols.find(Name);
+  if (Iter != std::end(Symbols)) {
+    Symbols.erase(Iter);
+    Size += sizeof(ELFT::Sym);
+  }
+}
+
+template <class ELFT> void SymbolTableSection<ELFT>::finalize() {
+  auto CompareBinding = [](const Symbol &a, const Symbol &b) {
+    return a.Binding < b.Binding;
+  };
+  auto CompareIndex = [](const Symbol &a, const Symbol &b) {
+    return a.Index < b.Index;
+  };
+  // Add all of our strings to SymbolNames and finalize the table
+  for (auto &Entry : Symbols)
+    SymbolNames->addString(Entry.second.Name);
+  SymbolNames->finalize();
+  for (auto &Entry : Symbols) {
+    Entry.second.NameIndex = SymbolNames->findIndex(Entry.second.Name);
+    FinalSymbols.push_back(Entry.second);
+  }
+  Symbol DummyLocal;
+  DummyLocal.Binding = STB_LOCAL;
+  std::sort(std::begin(FinalSymbols), std::end(FinalSymbols), CompareIndex);
+  std::stable_sort(std::begin(FinalSymbols), std::end(FinalSymbols),
+                   CompareBinding);
+  auto Iter = std::upper_bound(std::begin(FinalSymbols), std::end(FinalSymbols),
+                               DummyLocal, CompareBinding);
+  Info = std::end(FinalSymbols) - Iter;
+  Link = SymbolNames->Index;
+}
+
+template <class ELFT>
+void SymbolTableSection<ELFT>::writeSection(llvm::FileOutputBuffer &Out) const {
+  uint8_t *Buf = Out.getBufferStart();
+  Buf += Offset;
+  typename ELFT::Sym *Sym = reinterpret_cast<typename ELFT::Sym *>(Buf);
+  for (auto &Symbol : FinalSymbols) {
+    Sym->st_name = Symbol.NameIndex;
+    Sym->st_value = Symbol.Value;
+    Sym->st_size = Symbol.Size;
+    Sym->setBinding(Symbol.Binding);
+    Sym->setType(Symbol.Type);
+    if (Symbol.DefinedIn)
+      Sym->st_shndx = Symbol.DefinedIn->Index;
+    else
+      Sym->st_shndx = SHN_UNDEF;
+    ++Sym;
+  }
+}
+
 template <class ELFT>
 void Object<ELFT>::readProgramHeaders(const ELFFile<ELFT> &ElfFile) {
   uint32_t Index = 0;
@@ -101,6 +172,35 @@
   }
 }
 
+template <class ELFT>
+std::unique_ptr<SectionBase>
+Object<ELFT>::makeSection(const ELFFile<ELFT> &ElfFile, const Elf_Shdr &Shdr) {
+  ArrayRef<uint8_t> Data;
+  switch (Shdr.sh_type) {
+  case SHT_STRTAB:
+    return make_unique<StringTableSection>();
+  case SHT_SYMTAB: {
+    auto SymTab = make_unique<SymbolTableSection<ELFT>>();
+    StringRef StrTabData = unwrapOrError(ElfFile.getStringTableForSymtab(Shdr));
+    for (const auto &Sym : unwrapOrError(ElfFile.symbols(&Shdr))) {
+      SectionBase *DefSection = nullptr;
+      if (Sym.st_shndx != SHN_UNDEF)
+        DefSection = Sections[Sym.st_shndx - 1].get();
+      StringRef Name = unwrapOrError(Sym.getName(StrTabData));
+      SymTab->addSymbol(Name, Sym.getBinding(), Sym.getType(), DefSection,
+                        Sym.getValue(), Sym.st_size);
+    }
+    SymbolTable = SymTab.get();
+    return SymTab;
+  }
+  case SHT_NOBITS:
+    return make_unique<Section>(Data);
+  default:
+    Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
+    return make_unique<Section>(Data);
+  }
+}
+
 template <class ELFT>
 void Object<ELFT>::readSectionHeaders(const ELFFile<ELFT> &ElfFile) {
   uint32_t Index = 0;
@@ -109,12 +209,7 @@
       ++Index;
       continue;
     }
-    if (Shdr.sh_type == SHT_STRTAB)
-      continue;
-    ArrayRef<uint8_t> Data;
-    if (Shdr.sh_type != SHT_NOBITS)
-      Data = unwrapOrError(ElfFile.getSectionContents(&Shdr));
-    SecPtr Sec = make_unique<Section>(Data);
+    SecPtr Sec = makeSection(ElfFile, Shdr);
     Sec->Name = unwrapOrError(ElfFile.getSectionName(&Shdr));
     Sec->Type = Shdr.sh_type;
     Sec->Flags = Shdr.sh_flags;
@@ -126,9 +221,16 @@
     Sec->Align = Shdr.sh_addralign;
     Sec->EntrySize = Shdr.sh_entsize;
     Sec->Index = Index++;
-    SectionNames->addString(Sec->Name);
     Sections.push_back(std::move(Sec));
   }
+  if (SymbolTable) {
+    if (auto StrTab = dyn_cast<StringTableSection>(
+            Sections[SymbolTable->Link - 1].get())) {
+      SymbolTable->setStrTab(StrTab);
+    } else {
+      error("Symbol table has invalid string table");
+    }
+  }
 }
 
 template <class ELFT> size_t Object<ELFT>::totalSize() const {
@@ -148,13 +250,11 @@
   Entry = Ehdr.e_entry;
   Flags = Ehdr.e_flags;
 
-  Sections.push_back(make_unique<StringTableSection>());
-  SectionNames = dyn_cast<StringTableSection>(Sections.back().get());
-  SectionNames->Name = ".shstrtab";
-  SectionNames->addString(SectionNames->Name);
-
   readSectionHeaders(ElfFile);
   readProgramHeaders(ElfFile);
+
+  SectionNames =
+      dyn_cast<StringTableSection>(Sections[Ehdr.e_shstrndx - 1].get());
 }
 
 template <class ELFT> void Object<ELFT>::sortSections() {
@@ -208,6 +308,9 @@
   assignOffsets();
 
   // Finalize SectionNames first so that we can assign name indexes.
+  for (const auto &Section : Sections) {
+    SectionNames->addString(Section->Name);
+  }
   SectionNames->finalize();
   // Finally now that all offsets and indexes have been set we can finalize any
   // reamining issues.
@@ -239,7 +342,9 @@
   Ehdr.e_phentsize = sizeof(Elf_Phdr);
   Ehdr.e_phnum = Segments.size();
   Ehdr.e_shentsize = sizeof(Elf_Shdr);
-  Ehdr.e_shnum = Sections.size();
+  // The first entry in the seciton header table is not in Sections but must be
+  // accounted for when writing out the size
+  Ehdr.e_shnum = Sections.size() + 1;
   Ehdr.e_shstrndx = SectionNames->Index;
 }