Index: llvm/include/llvm/Object/ELFObjectFile.h
===================================================================
--- llvm/include/llvm/Object/ELFObjectFile.h
+++ llvm/include/llvm/Object/ELFObjectFile.h
@@ -394,7 +394,7 @@
   const Elf_Rel *getRel(DataRefImpl Rel) const;
   const Elf_Rela *getRela(DataRefImpl Rela) const;
 
-  const Elf_Sym *getSymbol(DataRefImpl Sym) const {
+  virtual const Elf_Sym *getSymbol(DataRefImpl Sym) const {
     auto Ret = EF.template getEntry<Elf_Sym>(Sym.d.a, Sym.d.b);
     if (!Ret)
       report_fatal_error(errorToErrorCode(Ret.takeError()).message());
Index: llvm/include/llvm/Object/MutableELFObject.h
===================================================================
--- llvm/include/llvm/Object/MutableELFObject.h
+++ llvm/include/llvm/Object/MutableELFObject.h
@@ -28,7 +28,6 @@
 // taking an Iterable::value_type.
 template <typename T> class MutableRange {
 public:
-
   using iterator = typename std::vector<MappingType>::iterator;
   using value_type = MappingType;
 
@@ -215,13 +214,27 @@
   iterator end() { return iterator(Sections.end(), ObjFile); }
 };
 
+template <typename ELFT> struct MutableELFSymbol {
+  Elf_Sym_Impl<ELFT> Header;
+  std::string Name;
+
+  MutableELFSymbol(uintptr_t ToCopy, const MutableELFObject<ELFT> *ObjFile)
+      : Header(*ObjFile->getOriginalSymbol(toDataRef(ToCopy))) {
+    auto NameOrErr = ObjFile->getSymbolName(toDataRef(ToCopy));
+    Name = NameOrErr ? *NameOrErr : "";
+  }
+};
+
 template <typename ELFT> class MutableELFObject : public ELFObjectFile<ELFT> {
   friend struct MutableELFSection<ELFT>;
   friend class MutableELFSegment<ELFT>;
   friend class SegmentRef<ELFT>;
+  friend struct MutableELFSymbol<ELFT>;
 
   MutableRange<MutableELFSection<ELFT>> Sections;
   MutableRange<MutableELFSegment<ELFT>> Segments;
+  MutableRange<MutableELFSymbol<ELFT>> Symbols;
+  MutableRange<MutableELFSymbol<ELFT>> DynamicSymbols;
 
 protected:
   const Elf_Ehdr_Impl<ELFT> &header() {
@@ -236,13 +249,33 @@
     MappingType Mapping = Sections[Sec.p];
     if (Mapping.IsNew)
       return &Sections.getNew(Mapping.Ptr)->Header;
-    return reinterpret_cast<const Elf_Shdr_Impl<ELFT>*>(Mapping.Ptr);
+    return reinterpret_cast<const Elf_Shdr_Impl<ELFT> *>(Mapping.Ptr);
+  }
+
+  const Elf_Sym_Impl<ELFT> *getOriginalSymbol(DataRefImpl Sym) const {
+    return ELFObjectFile<ELFT>::getSymbol(Sym);
+  }
+
+  const Elf_Sym_Impl<ELFT> *getSymbol(DataRefImpl Sym) const override {
+    const Elf_Shdr_Impl<ELFT> *Sec =
+        getSection(toDataRef(static_cast<uintptr_t>(Sym.d.a)));
+    const MutableRange<MutableELFSymbol<ELFT>> *SymbolRange = &Symbols;
+    if (Sec->sh_type == ELF::SHT_DYNSYM)
+      SymbolRange = &DynamicSymbols;
+    assert(Sec->sh_type == ELF::SHT_SYMTAB && "Expected symbol table");
+    MappingType Mapping = SymbolRange->operator[](Sym.d.b);
+    if (Mapping.IsNew)
+      return &SymbolRange->getNew(Mapping.Ptr)->Header;
+    assert(Mapping.Ptr - (uintptr_t)this->base() >= Sec->sh_offset &&
+           Mapping.Ptr - (uintptr_t)this->base() <
+               Sec->sh_offset + Sec->sh_size &&
+           "Pointer not in symbol table");
+    return reinterpret_cast<const Elf_Sym_Impl<ELFT> *>(Mapping.Ptr);
   }
 
   const Elf_Shdr_Impl<ELFT> &getSectionHeader(uint64_t Index) const;
   const Elf_Shdr_Impl<ELFT> &getSectionHeader(section_iterator Sec) const;
   const Elf_Phdr_Impl<ELFT> &getSegmentHeader(uint64_t Index) const;
-  //Elf_Phdr_Impl<ELFT> &getSegmentHeader(uint64_t Index);
 
   void moveSectionNext(DataRefImpl &Sec) const override;
   Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
@@ -260,7 +293,6 @@
   uint64_t getSegmentAlign(uint64_t Index) const;
   bool segmentHasSection(uint64_t Segment, uint64_t Section) const;
 
-
 public:
   explicit MutableELFObject(ELFObjectFile<ELFT> &B)
       : ELFObjectFile<ELFT>(std::move(B)),
@@ -279,7 +311,23 @@
                                reinterpret_cast<uintptr_t>(Phdrs + Index),
                                /*IsNew=*/false);
                          });
-        }) {}
+        }),
+        Symbols([this](std::vector<MappingType> &Vec) {
+          section_iterator Iter = std::find_if(
+              section_begin(), section_end(), [this](section_iterator Sec) {
+                return getSectionHeader(Sec).sh_type == ELF::SHT_SYMTAB;
+              });
+          if (Iter == section_end())
+            return;
+          Elf_Shdr_Impl<ELFT> Header = getSectionHeader(Iter);
+          size_t NumSyms = Header.sh_size / sizeof(Elf_Sym_Impl<ELFT>);
+          uintptr_t Start =
+              Header.sh_offset + reinterpret_cast<uintptr_t>(this->base());
+          for (size_t I : seq((size_t)0, NumSyms))
+            Vec.emplace_back(Start + I * sizeof(Elf_Sym_Impl<ELFT>),
+                             /*IsNew=*/false);
+        }),
+        DynamicSymbols([](std::vector<MappingType> &Vec) {}) {}
 
   section_iterator section_begin() const override {
     return section_iterator(SectionRef(toDataRef(0), this));
Index: llvm/unittests/Object/MutableELFObjectTest.cpp
===================================================================
--- llvm/unittests/Object/MutableELFObjectTest.cpp
+++ llvm/unittests/Object/MutableELFObjectTest.cpp
@@ -50,7 +50,7 @@
   ASSERT_TRUE(ELFObjFile);
   MutableELFObject<ELF64LE> MutableObject(*ELFObjFile);
 
-  auto compareSectionName = [](section_iterator Iter, const char * Name) {
+  auto compareSectionName = [](section_iterator Iter, const char *Name) {
     StringRef SecName;
     EXPECT_FALSE(Iter->getName(SecName));
     EXPECT_EQ(SecName, Name);
@@ -121,9 +121,8 @@
   FirstSec = ++MutableObject.section_begin();
   Contents = FirstSec->getContents();
   ASSERT_THAT_EXPECTED(Contents, Succeeded());
-  EXPECT_EQ(*Contents,
-            StringRef(reinterpret_cast<const char *>(Data.data()),
-                      Data.size()));
+  EXPECT_EQ(*Contents, StringRef(reinterpret_cast<const char *>(Data.data()),
+                                 Data.size()));
 
   MutSec->Header.sh_size = 2;
   Contents = FirstSec->getContents();
@@ -377,3 +376,44 @@
   EXPECT_TRUE(MutableSegment->hasSection(BssSection));
   EXPECT_TRUE(SecondSegment->hasSection(BssSection));
 }
+
+// Test symbols
+TEST(MutableELFObject, NoChangeSymbol) {
+  SmallString<0> Storage;
+  Expected<std::unique_ptr<ObjectFile>> ErrOrObj = yaml2ObjectFile(Storage, R"(
+--- !ELF
+FileHeader:
+  Class:     ELFCLASS64
+  Data:      ELFDATA2LSB
+  Type:      ET_REL
+  Machine:   EM_X86_64
+Symbols:
+  - Name:     test
+    Index:    SHN_ABS
+    Value:    0x1234
+    Binding:  STB_LOCAL
+  - Name:     second
+    Index:    SHN_ABS
+    Value:    0
+    Binding:  STB_GLOBAL)");
+
+  ASSERT_THAT_EXPECTED(ErrOrObj, Succeeded());
+  auto *ELFObjFile = dyn_cast<ELFObjectFile<ELF64LE>>(ErrOrObj->get());
+  ASSERT_TRUE(ELFObjFile);
+  MutableELFObject<ELF64LE> MutableObject(*ELFObjFile);
+
+  auto TestSym = symbol_iterator(MutableObject.symbol_begin());
+  EXPECT_EQ(TestSym->getValue(), 0x1234U);
+  // STB_LOCAL means not SF_Global
+  EXPECT_FALSE(TestSym->getFlags() & SymbolRef::SF_Global);
+  auto NameOrErr = TestSym->getName();
+  ASSERT_THAT_EXPECTED(NameOrErr, Succeeded());
+  EXPECT_EQ(*NameOrErr, "test");
+
+  auto SecondSym = symbol_iterator(++TestSym);
+  EXPECT_EQ(SecondSym->getValue(), 0U);
+  EXPECT_TRUE(SecondSym->getFlags() & SymbolRef::SF_Global);
+  NameOrErr = SecondSym->getName();
+  ASSERT_THAT_EXPECTED(NameOrErr, Succeeded());
+  EXPECT_EQ(*NameOrErr, "second");
+}