Index: llvm/tools/llvm-objcopy/MutableObject/MutableObject.h
===================================================================
--- /dev/null
+++ llvm/tools/llvm-objcopy/MutableObject/MutableObject.h
@@ -0,0 +1,154 @@
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Object/ELF.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ELFTypes.h"
+#define protected public
+#include "llvm/Object/ObjectFile.h"
+#undef protected
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include <cassert>
+#include <memory>
+#include <unordered_map>
+
+using namespace llvm;
+using namespace object;
+
+template <typename ELFT> class MutableELFObject;
+
+class SectionBase {
+protected:
+  ArrayRef<uint8_t> Data;
+  StringRef Name;
+
+public:
+  SectionBase() = default;
+  SectionBase(const SectionBase &) = default;
+  SectionBase(SectionBase &&) = default;
+  SectionBase(ArrayRef<uint8_t> Data, StringRef Name) : Data(Data), Name(Name) {}
+  virtual ~SectionBase() {}
+
+  StringRef name() const { return Name; }
+
+  virtual SectionBase *clone(Optional<StringRef> NewName = None) const {
+    auto Ptr = new SectionBase(*this);
+    if (NewName)
+      Ptr->Name = *NewName;
+    return Ptr;
+  }
+};
+
+class MutableObject {
+// Access modifiers are pretty permissive throughout for now because
+// I can't be bothered to make getters.
+protected:
+  using SecPtr = std::unique_ptr<SectionBase>;
+  using key_t = uint64_t;
+
+  std::unordered_map<key_t, SecPtr> UpdatedSections;
+
+  std::vector<SecPtr> Sections;
+
+  class section_range {};
+
+public:
+  MutableObject() = default;
+  MutableObject(const MutableObject &) = default;
+  MutableObject(MutableObject &&) = default;
+  virtual ~MutableObject() {}
+  virtual Error init() = 0;
+
+  virtual const uint8_t *base() const = 0;
+
+  Error renameSection(uint64_t Index, StringRef NewName) {
+    if (Index > Sections.size())
+      return createError("section doesn't exist");
+    UpdatedSections[Index] =
+      std::unique_ptr<SectionBase>(Sections[Index]->clone(NewName));
+    return Error::success();
+  }
+
+  Optional<const SectionBase *> getSection(uint64_t Index) const {
+    // Searching if the key exists so is_contained doesn't work.
+    auto Found = UpdatedSections.find(Index);
+    if (Found != UpdatedSections.end()) {
+        if (Found->second.get())
+          return Found->second.get();
+        return None;
+    }
+    if (Index > Sections.size()) return None;
+    return Sections[Index].get();
+  }
+
+  section_range sections() const;
+};
+
+template <typename ELFT>
+class ELFSection : public SectionBase {
+  const Elf_Shdr_Base<ELFT> &Shdr;
+
+public:
+  ELFSection(const Elf_Shdr_Base<ELFT> &Shdr, MutableELFObject<ELFT> &Object)
+  : SectionBase(ArrayRef<uint8_t>(Object.base() + Shdr.sh_offset, Shdr.sh_size),
+  Object.nameFromShstrtab(Shdr.sh_name)), Shdr(Shdr) {}
+
+  ELFSection(const ELFSection &) = default;
+  ELFSection(ELFSection &&) = default;
+
+  ELFSection *clone(Optional<StringRef> NewName = None) const override {
+    auto Ptr = new ELFSection<ELFT>(*this);
+    if (NewName)
+      Ptr->Name = *NewName;
+    return Ptr;
+  }
+};
+
+template <typename ELFT>
+class MutableELFObject : public MutableObject {
+  ELFObjectFile<ELFT> &Object;
+  ArrayRef<uint8_t> Shstrtab;
+
+public:
+  MutableELFObject(ELFObjectFile<ELFT> &Object) : Object(Object) {}
+
+  Error init() override;
+
+  const uint8_t *base() const override {
+    return Object.base();
+  }
+
+  static StringRef nameFromStrtab(uint64_t Index, ArrayRef<uint8_t> Strtab) {
+    if (!Strtab.data())
+      return StringRef();
+
+    assert(Index < Strtab.size());
+    return reinterpret_cast<const char*>(Strtab.data()) + Index;
+  }
+
+  StringRef nameFromShstrtab(uint64_t Index) const { return nameFromStrtab(Index, Shstrtab); }
+};
+
+template <typename ELFT>
+Error MutableELFObject<ELFT>::init() {
+  auto &Header = *Object.getELFFile()->getHeader();
+  auto SectionsOrErr = Object.getELFFile()->sections();
+  if (!SectionsOrErr)
+    return SectionsOrErr.takeError();
+  auto SectionArr = SectionsOrErr.get();
+  Shstrtab = ArrayRef<uint8_t>(base() + SectionArr[Header.e_shstrndx].sh_offset,
+    SectionArr[Header.e_shstrndx].sh_size);
+
+  Sections.reserve(Header.e_shnum);
+  for (const auto &Shdr : SectionArr) {
+    // Later construct different classes derived from ELF section but
+    // for now just create an ELFSection.
+    switch (Shdr.sh_type) {
+      default:
+        Sections.emplace_back(make_unique<ELFSection<ELFT>>(Shdr, *this));
+    }
+  }
+
+  return Error::success();
+}
Index: llvm/tools/llvm-objcopy/llvm-objcopy.cpp
===================================================================
--- llvm/tools/llvm-objcopy/llvm-objcopy.cpp
+++ llvm/tools/llvm-objcopy/llvm-objcopy.cpp
@@ -46,6 +46,8 @@
 #include <system_error>
 #include <utility>
 
+#include "MutableObject/MutableObject.h"
+
 namespace llvm {
 namespace objcopy {
 
@@ -209,7 +211,7 @@
   if (Config.PreserveDates)
     if (auto EC = sys::fs::status(Config.InputFilename, Stat))
       return createFileError(Config.InputFilename, EC);
-  
+
   if (Config.InputFormat == "binary") {
     auto BufOrErr = MemoryBuffer::getFile(Config.InputFilename);
     if (!BufOrErr)
@@ -245,9 +247,48 @@
   return Error::success();
 }
 
+static Error testing(StringRef Filename) {
+  Expected<OwningBinary<llvm::object::Binary>> BinaryOrErr =
+    object::createBinary(Filename);
+  if (!BinaryOrErr)
+    return createFileError(Filename, BinaryOrErr.takeError());
+
+  auto *ELFBinary = dyn_cast<object::ELFObjectFile<ELF64LE>>(BinaryOrErr->getBinary());
+  if (!ELFBinary)
+    return createError("not an ELF file");
+
+  auto MutObject = MutableELFObject<ELF64LE>(*ELFBinary);
+  if (Error E = MutObject.init())
+    return E;
+
+  outs() << MutObject.nameFromShstrtab(1) << "\n";
+
+  auto Sec = MutObject.getSection(1).getValue()->name();
+  outs() << Sec << "\n";
+
+  if (Error E = MutObject.renameSection(1, ".sec.new"))
+    return E;
+
+  auto NewSec = MutObject.getSection(1).getValue()->name();
+  outs() << NewSec << "\n";
+
+  assert(NewSec != Sec);
+  assert(NewSec == ".sec.new");
+
+  return Error::success();
+}
+
 int main(int argc, char **argv) {
   InitLLVM X(argc, argv);
   ToolName = argv[0];
+  if (!strcmp(argv[1], "TEST")) {
+    if (Error E = testing(argv[2])) {
+      logAllUnhandledErrors(std::move(E), WithColor::error(errs(), ToolName));
+      return 1;
+    }
+    return 0;
+  }
+
   bool IsStrip = sys::path::stem(ToolName).contains("strip");
   Expected<DriverConfig> DriverConfig =
       IsStrip ? parseStripOptions(makeArrayRef(argv + 1, argc))