Index: llvm/include/llvm/Object/MutableELFObject.h
===================================================================
--- /dev/null
+++ llvm/include/llvm/Object/MutableELFObject.h
@@ -0,0 +1,199 @@
+//===-- MutableELFObject.h --------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_MUTABLEELFOBJECT_H
+#define LLVM_OBJECT_MUTABLEELFOBJECT_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/MutableObject.h"
+
+namespace llvm {
+namespace object {
+
+template <typename ELFT> class MutableELFObject;
+
+template <typename T>
+static inline DataRefImpl toDataRef(T Ptr) {
+  DataRefImpl Ref;
+  Ref.p = reinterpret_cast<uintptr_t>(Ptr);
+  return Ref;
+}
+
+template <typename ELFT> class MutableELFSection {
+public:
+  Elf_Shdr_Impl<ELFT> Header;
+  std::string Name;
+  OwningArrayRef<uint8_t> Data;
+
+  MutableELFSection(uintptr_t ToCopy, const MutableELFObject<ELFT> *ObjFile)
+      : Header(*ObjFile->getSection(toDataRef(ToCopy))),
+        Data(OwningArrayRef<uint8_t>(Header.sh_size)) {
+    ::memcpy(Data.data(), ObjFile->base() + Header.sh_offset, Header.sh_size);
+  }
+};
+
+template <typename ELFT> class MutableELFObject : public ELFObjectFile<ELFT> {
+  friend class MutableELFSection<ELFT>;
+
+  MutableRange<MutableELFSection<ELFT>> Sections;
+
+protected:
+  using MappingType =
+      typename MutableRange<MutableELFSection<ELFT>>::MappingType;
+
+  void moveSectionNext(DataRefImpl &Sec) const override;
+  Expected<StringRef> getSectionName(DataRefImpl Sec) const override;
+  uint64_t getSectionAddress(DataRefImpl Sec) const override;
+  uint64_t getSectionIndex(DataRefImpl Sec) const override;
+  uint64_t getSectionSize(DataRefImpl Sec) const override;
+  Expected<ArrayRef<uint8_t>>
+  getSectionContents(DataRefImpl Sec) const override;
+  uint64_t getSectionAlignment(DataRefImpl Sec) const override;
+  bool isSectionCompressed(DataRefImpl Sec) const override;
+  bool isSectionText(DataRefImpl Sec) const override;
+  bool isSectionData(DataRefImpl Sec) const override;
+  bool isSectionBSS(DataRefImpl Sec) const override;
+  bool isSectionVirtual(DataRefImpl Sec) const override;
+  bool isBerkeleyText(DataRefImpl Sec) const override;
+  bool isBerkeleyData(DataRefImpl Sec) const override;
+
+public:
+  MutableELFObject(ELFObjectFile<ELFT> &B)
+      : ELFObjectFile<ELFT>(std::move(B)),
+        Sections(B.section_begin(), B.section_end(),
+                 [&](SectionRef Ref) { return Ref.getRawDataRefImpl().p; }) {}
+
+  section_iterator section_begin() const override {
+    return section_iterator(SectionRef(toDataRef(0UL), this));
+  }
+
+  section_iterator section_end() const override {
+    return section_iterator(SectionRef(toDataRef(Sections.size()), this));
+  }
+
+  MutableELFSection<ELFT> *getMutableSection(section_iterator Sec) {
+    uintptr_t Index = Sec->getRawDataRefImpl().p;
+    return Sections.makeMutable(Index, this);
+  }
+};
+
+template <typename ELFT>
+void MutableELFObject<ELFT>::moveSectionNext(DataRefImpl &Sec) const {
+  ++Sec.p;
+}
+
+template <typename ELFT>
+Expected<StringRef>
+MutableELFObject<ELFT>::getSectionName(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  if (Mapping.New) {
+    const MutableELFSection<ELFT> *NewSec = Sections.getNew(Mapping.Ptr);
+    return NewSec->Name;
+  }
+  return ELFObjectFile<ELFT>::getSectionName(toDataRef(Mapping.Ptr));
+}
+
+template <typename ELFT>
+uint64_t MutableELFObject<ELFT>::getSectionAddress(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::getSectionAddress(Ref);
+}
+
+template <typename ELFT>
+uint64_t MutableELFObject<ELFT>::getSectionIndex(DataRefImpl Sec) const {
+  return Sec.p;
+}
+
+template <typename ELFT>
+uint64_t MutableELFObject<ELFT>::getSectionSize(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::getSectionSize(Ref);
+}
+
+template <typename ELFT>
+Expected<ArrayRef<uint8_t>>
+MutableELFObject<ELFT>::getSectionContents(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::getSectionContents(Ref);
+}
+
+template <typename ELFT>
+uint64_t MutableELFObject<ELFT>::getSectionAlignment(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::getSectionAlignment(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isSectionCompressed(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isSectionCompressed(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isSectionText(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isSectionText(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isSectionData(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isSectionData(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isSectionBSS(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isSectionBSS(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isSectionVirtual(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isSectionVirtual(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isBerkeleyText(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isBerkeleyText(Ref);
+}
+
+template <typename ELFT>
+bool MutableELFObject<ELFT>::isBerkeleyData(DataRefImpl Sec) const {
+  MappingType Mapping = Sections[Sec.p];
+  DataRefImpl Ref = Mapping.New ? toDataRef(Sections.getNew(Mapping.Ptr))
+                                : toDataRef(Mapping.Ptr);
+  return ELFObjectFile<ELFT>::isBerkeleyData(Ref);
+}
+
+} // namespace object
+} // namespace llvm
+
+#endif // LLVM_OBJECT_MUTABLEELFOBJECT_H
Index: llvm/include/llvm/Object/MutableObject.h
===================================================================
--- /dev/null
+++ llvm/include/llvm/Object/MutableObject.h
@@ -0,0 +1,78 @@
+//===-- MutableObject.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_OBJECT_MUTABLEOBJECT_H
+#define LLVM_OBJECT_MUTABLEOBJECT_H
+
+namespace llvm {
+namespace object {
+
+// T is a wrapper type around Iterable::value_type and must have a constructor
+// taking an Iterable::value_type.
+template <typename T> class MutableRange {
+public:
+  struct MappingType {
+    bool New : 1;
+    uintptr_t Ptr : sizeof(void *) * 8 - 1;
+
+    MappingType(bool New, uintptr_t Ptr) : New(New), Ptr(Ptr) {}
+
+    uintptr_t getPtr() const { return Ptr; }
+  };
+
+  using iterator = typename std::vector<MappingType>::iterator;
+  using value_type = MappingType;
+
+private:
+  std::vector<MappingType> Mappings;
+  std::vector<T> NewValues;
+
+public:
+  template <typename Iterable>
+  MutableRange(
+      Iterable Range,
+      function_ref<uintptr_t(typename Iterable::iterator::value_type)> Extract)
+      : MutableRange(Range.begin(), Range.end(), Extract) {}
+
+  template <typename Iter>
+  MutableRange(Iter Begin, Iter End,
+               function_ref<uintptr_t(typename Iter::value_type)> Extract) {
+    std::transform(Begin, End, std::back_inserter(Mappings),
+                   [&Extract](typename Iter::value_type Value) -> MappingType {
+                     uintptr_t Extracted = Extract(Value);
+                     assert(Extracted <= (UINT64_MAX >> 1) &&
+                            "returned type too large");
+                     return MappingType(false, Extracted);
+                   });
+  }
+
+  MappingType operator[](uint64_t Index) const { return Mappings[Index]; }
+
+  size_t size() const { return Mappings.size(); }
+
+  iterator begin() { return Mappings.begin(); }
+  iterator end() { return Mappings.end(); }
+
+  const T *getNew(uint64_t Index) const { return &NewValues[Index]; }
+  T *getNew(uint64_t Index) { return &NewValues[Index]; }
+
+  template <typename... Args>
+  T *makeMutable(uint64_t Index, Args &&... Arguments) {
+    MappingType Mapping = Mappings[Index];
+    if (Mapping.New)
+      return &NewValues[reinterpret_cast<uintptr_t>(Mapping.Ptr)];
+    NewValues.emplace_back(Mapping.getPtr(), Arguments...);
+    Mappings[Index] = MappingType(true, NewValues.size() - 1);
+    return &NewValues.back();
+  }
+};
+
+} // namespace object
+} // namespace llvm
+
+#endif // LVM_OBJECT_MUTABLEOBJECT_H