Create MutableObjectWriter class

[abrachet]

llvm/tools/llvm-objcopy/ELF/Object.h

1191

I'm not sure if I'm using StringTableBuilder incorrectly. An assertion failed saying that the string was not in the table. I looked into it with lldb and manually added the string it said was not there, it still didn't work.

[jhenderson]

I've made a number of first-pass comments for you.

llvm/tools/llvm-objcopy/ELF/Object.h

1122–1124

Don't need to add this now, but some TODOs to add are:

1. What to do if the string table index is a removed section.
2. What to do if the e_shstrndx value is either SHN_XINDEX.
3. What to do if the e_shstrndx value is 0.

1128

This shouldn't be an assert. What if the e_shstrndx value points at a non-string table?

1164

This seems like an unnecessary copy here. Why can't it wait until you actually need to write the .shstrtab to the buffer?

1166–1175

This block of code is very similar to the above block. Consider sharing it.

1191

I can't see from the code what is going wrong. Check to make sure that the strings are actually added to the StringTableBuilder when you call add, and take a look at the return values from that. I doubt they'll be much different from what getOffset eventually will return.

Also, setting the section name isn't part of laying out a section, so this feels like it's being done in the wrong palce.

1199

What about segments that are nested in other segments? This code doesn't handle that.

1205

What if a program header covers the ELF header and program header table? This code won't work for that.

1214–1215

I think you've got this alignment in the wrong place. I'm pretty sure it should be before the offset is set...

1225–1227

It would be easier to see what's going on with a traditional for loop here.

1274

What about data within segments not covered by sections? This code doesn't handle that.

[abrachet]

Put option to use writer behind flag. Other large changes

[abrachet]

Use right diff

[abrachet]

Fixed UB bug. Still doesn't write correctly, llvm-readelf says the shstrtab is not null terminated, presumably the other sections are written poorly too.

[jhenderson]

Overall, the design looks pretty good now. I think it is clear to me what is happening. I do think you need to write significantly more tests though. Possibly the way to do it is to add a case to the existing tests for basic copies using the switch, and show that the output is identical. If it isn't, you need to understand why there are differences and whether they are important.

llvm/test/tools/llvm-objcopy/ELF/mutable-object-no-change.test

1

coppied -> copied

Copied under what circumstance? Perhaps "is properly copied when using the mutable object interface, and no switches are specified".

3–12

It's more normal to put the YAML at the end of the test.

I think your test case needs to test program headers and symbols too, so this needs some of each. Perhaps a separate test case would be appropriate to test segment layout for nested segments.

16

Delete the extra blank line.

llvm/tools/llvm-objcopy/CommonOpts.td

87

ObjectFile -> Object

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

818

/// -> //

Maybe make this comment more explanatory too.

827

I'm hesitant about this not taking an r-value reference or copy, because you std::move it further down the stack. This feels like it might be at risk of surprising a user of the interface later on.

llvm/tools/llvm-objcopy/ELF/Object.cpp

2313

Probably worth a using for the typename ELFT::Phdr type, maybe even in the class definition.

2332

Shouldn't this be Obj.getHeader().e_phnum * sizeof(Phdr)?

2337

Maybe a stable_sort would be a good plan here?

2354

What if the parent segment hasn't been laid out yet? I believe that you could theoretically have the parent segment after the child segment, in the ordered vector, if the alignment of the parent is greater than an otherwise identical child.

2369

Why?

(I know it's the null section, but it's a good idea to be clear about it)

2385

Huh? Do you mean to be using sh_addralign here?

2476

Nit: delete the blank line

[abrachet]

Addressed review comments

[abrachet]

I didn't get to all comments yet, and I also haven't added more tests because currently the object file isn't being create properly. Once I am making a valid ELF file I will do more rigorous testing.

Right now llvm-readelf complains that that the .shstrtab is not null terminated, so probably a layout issue of sections. I've been looking into it and couldn't find the problem yet. My section offsets are slightly lower than how llvm-objcopy currently does layout. Does anyone have any ideas why that is?

Currently this patch creates sections at offsets 0, 38, 38, 50, 51 and llvm-objcopy does 0, 40, 40, 58, 59 (both with no arguments)

llvm/test/tools/llvm-objcopy/ELF/mutable-object-no-change.test

3–12

Oops forgot to do the first part, I'll do that in a later diff. Haven't done second part see my out of line comment.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

827

There is no copy constructor for ObjectFiles so I could make one for MutableELFObject, I can't move In or *O the compiler says. I don't really know the intricacies of when you can and cannot move an object, probably I could move the OwningObjectFile though, this would require larger changes to this method. Do you have any thoughts?

llvm/tools/llvm-objcopy/ELF/Object.cpp

2332

Good catch :)

2337

I actually just learned about this today in class and was thinking it was just what I needed :)

2354

I haven't gotten around to this yet because I have bigger problems that I want to address before potentially adding more bugs.

I can do this the quick way which would be having an std::set<size_t> and whenever *ParentIndex is larger than Index I layout that segment and then add it to the set and check every iteration of the loop if Index is in there. Seems ugly though. I could also a bool laidOut to MutableELFSegment<ELFT> because its ok to make every segment mutable because there are so few of them I believe.

2385

Oh yes thanks!

2476

Are you sure? There was previously a blank line between template class ELFWriter<ELF32BE>; and the end of namesapce elf. I think it looks better too.

[jhenderson]

In D66403#1650286, @abrachet wrote:

I didn't get to all comments yet, and I also haven't added more tests because currently the object file isn't being create properly. Once I am making a valid ELF file I will do more rigorous testing.

Right now llvm-readelf complains that that the .shstrtab is not null terminated, so probably a layout issue of sections. I've been looking into it and couldn't find the problem yet. My section offsets are slightly lower than how llvm-objcopy currently does layout. Does anyone have any ideas why that is?

No idea myself off the top of my head, but the best thing to do is probably just to manually look at the produced object in a hex viewer, and see what looks wrong (consider section sizes, the section offset, and whether the right section is marked as the section header string table).

Currently this patch creates sections at offsets 0, 38, 38, 50, 51 and llvm-objcopy does 0, 40, 40, 58, 59 (both with no arguments)

I'd try manually laying out the ELF by hand, and see what your calculations come to, then compare them to what happens when you run the tool with a debugger. Where do the offsets start differing, and what causes that? Obvious suggestion might be problems with alignment, but I don't know.

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

827

I don't really think we want a copy, thinking about it more. We probably do want an r-value reference though. I'd change the signatures and call sites as follows, assuming it works (not had the time to verify them myself):

return elf::executeObjcopyWithMutableObject(Config, std::move(*ELFBinary), Out)

Error executeObjcopyWithMutableObject(const CopyConfig &Config,
                                      object::ELFObjectFileBase &&In,
                                      Buffer &Out) {
  ...
  return handleArgsAndWrite(std::move(*O), Out)
}

Error handleArgsAndWrite(ELFObjectFile<ELFT> &&Obj, Buffer &Out)

llvm/tools/llvm-objcopy/ELF/Object.cpp

2327–2332

Adding the segments like this is a good idea taken from llvm-objcopy's existing handling (even if I do say so myself, since I remember suggesting this originally!), but where do you prevent them actually being written out?

2354

I don't think you need to add a member to MutableELFSegment. You could have a local vector/map of bool though, so you can do IsLaidOut[Index] and just check and update that value at appropriate times.

2369

Thinking about it from a strict correctness point of view, I think you just want to skip all sections with type SHT_NULL. From the gABI:

SHT_NULL - This value marks the section header as inactive; it does not have an associated section. Other members of the section header have undefined values.

2385

clang-format?

2458

I might be being blind, but where do you write the program header table?

2476

My mistake. I misread the old diff. Please re-add!

llvm/tools/llvm-objcopy/ELF/Object.h

360–363

Canonical names are Elf_Ehdr, Elf_Phdr etc.

llvm/include/llvm/Object/MutableELFObject.h

template <typename ELFT> struct MutableELFSymbol {
   operator const Elf_Sym &() const { return Header; }
 };
 
 template <typename ELFT> class MutableELFSegment {
   using Elf_Phdr = Elf_Phdr_Impl<ELFT>;
 
 public:
   Elf_Phdr Header;
+  ArrayRef<uint8_t> OriginalData;
   Optional<size_t> ParentIndex;
 
-  MutableELFSegment(Elf_Phdr Header, Optional<size_t> ParentIndex)
-      : Header(Header), ParentIndex(ParentIndex) {}
+  MutableELFSegment(Elf_Phdr Header, ArrayRef<uint8_t> OriginalData,
+                    Optional<size_t> ParentIndex)
+      : Header(Header), OriginalData(OriginalData), ParentIndex(ParentIndex) {}
 
   operator const Elf_Phdr &() const { return Header; }
 };
 
 template <typename ELFT> class MutableELFObject : public ELFObjectFile<ELFT> {
   /// This class is used for a 'copy on write' effect with tables in an ELF
   /// object file.
   ///
explicit MutableELFObject(ELFObjectFile<ELFT> &&B)
                                         this->base() + getHeader().e_phoff),
                                     getHeader().e_phnum)),
         Sections(ArrayRef<Elf_Shdr>(reinterpret_cast<const Elf_Shdr *>(
                                         this->base() + getHeader().e_shoff),
                                     getHeader().e_shnum)),
         Symbols(findSymbolTable(ELF::SHT_SYMTAB)),
         DynSymbols(findSymbolTable(ELF::SHT_DYNSYM)) {}
 
+  using ELFObjectFile<ELFT>::base;
+
   using segment_iterator = content_iterator<SegmentRef>;
 
   section_iterator section_begin() const override {
     return section_iterator(
         SectionRef(toDataRef(Sections.getFirstIndex()), this));
   }
 
   section_iterator section_end() const override {
public:
   segment_iterator segment_end() {
     return segment_iterator(SegmentRef(this, Segments.getEndIndex()));
   }
 
   iterator_range<segment_iterator> segments() {
     return iterator_range<segment_iterator>(segment_begin(), segment_end());
   }
 
+  const Elf_Phdr &getOriginalSegment(size_t Index) const {
+    return Segments.getOriginal(Index);
+  }
+
   /// Returns a mutable reference to the symbol at the specified index.
   Expected<MutableELFSymbol<ELFT> &> getMutableSymbol(SymbolRef Sym) {
     Expected<StringRef> Name = getSymbolName(Sym.getRawDataRefImpl());
     if (!Name)
       return Name.takeError();
     return Symbols.makeMutable(Sym.getRawDataRefImpl().d.b,
                                Symbols[Sym.getRawDataRefImpl().d.b], *Name);
   }
if (!Name)
       return Name.takeError();
     return Sections.makeMutable(Sec.getRawDataRefImpl().p, Header, *Name,
                                 findParentSegment(Sec), this);
   }
 
   /// Returns a mutable reference to a segment.
   Expected<MutableELFSegment<ELFT> &> getMutableSegment(SegmentRef Segment) {
     const Elf_Phdr &Phdr = Segments[Segment.getIndex()];
-    return Segments.makeMutable(Segment.getIndex(), Phdr,
-                                findParentSegment(Segment));
+    return Segments.makeMutable(
+        Segment.getIndex(), Phdr,
+        ArrayRef<uint8_t>(this->base() + Phdr.p_offset, Phdr.p_filesz),
   }
 
   void addSymbol(MutableELFSymbol<ELFT> Sym) { Symbols.add(std::move(Sym)); }
 
   void addSection(MutableELFSection<ELFT> Sec) { Sections.add(std::move(Sec)); }
 
+  void addSegment(MutableELFSegment<ELFT> Seg) { Segments.add(std::move(Seg)); }
+
   /// Removes a symbol.
   void removeSymbol(SymbolRef Sym) {
     assert(Sections.getOriginal(Sym.getRawDataRefImpl().d.a).sh_type ==
                ELF::SHT_SYMTAB &&
            "Not pointing to symbol table");
     assert(Sym.getRawDataRefImpl().d.b && "Cannot remove index 0 symbol");
     Symbols.remove(Sym.getRawDataRefImpl().d.b);
   }

llvm/test/tools/llvm-objcopy/ELF/mutable-object-no-change.test

+## Test that the object file is properly coppied.
+
+--- !ELF
+FileHeader:
+  Class:   ELFCLASS64
+  Data:    ELFDATA2LSB
+  Type:    ET_REL
+  Machine: EM_X86_64
+Sections:
+  - Name:  .test
+    Type:  SHT_PROGBITS
+    Flags: [ SHF_ALLOC ]
+
+# RUN: yaml2obj %s | llvm-objcopy --use-mutable-object - %t
+# RUN: llvm-readobj --sections %t | FileCheck %s
+
+
+# CHECK:     Name: .test
+# CHECK:     Name: .shstrtab

llvm/tools/llvm-objcopy/CommonOpts.td

defm keep_symbol : Eq<"keep-symbol", "Do not remove symbol <symbol>">,
                    MetaVarName<"symbol">;
 def K : JoinedOrSeparate<["-"], "K">,
         Alias<keep_symbol>,
         HelpText<"Alias for --keep-symbol">;
 
 def keep_file_symbols : Flag<["--"], "keep-file-symbols">,
                         HelpText<"Do not remove file symbols">;
 
+def use_mutable_object : Flag<["--"], "use-mutable-object">,
+                        HelpText<"Use MutableELFObject instead of ObjectFile">;
+
 def only_keep_debug
     : Flag<["--"], "only-keep-debug">,
       HelpText<"Clear sections that would not be stripped by --strip-debug. "
                "Currently only implemented for COFF.">;
 
 def discard_locals : Flag<["--"], "discard-locals">,
                      HelpText<"Remove compiler-generated local symbols, (e.g. "
                               "symbols starting with .L)">;

llvm/tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
   bool StripAllGNU = false;
   bool StripDWO = false;
   bool StripDebug = false;
   bool StripNonAlloc = false;
   bool StripSections = false;
   bool StripUnneeded = false;
   bool Weaken = false;
   bool DecompressDebugSections = false;
+  bool UseMutableObject = false;
   DebugCompressionType CompressionType = DebugCompressionType::None;
 };
 
 // Configuration for the overall invocation of this tool. When invoked as
 // objcopy, will always contain exactly one CopyConfig. When invoked as strip,
 // will contain one or more CopyConfigs.
 struct DriverConfig {
   SmallVector<CopyConfig, 1> CopyConfigs;

llvm/tools/llvm-objcopy/CopyConfig.cpp

if (InputArgs.hasArg(OBJCOPY_discard_all, OBJCOPY_discard_locals))
     Config.DiscardMode =
         InputArgs.hasFlag(OBJCOPY_discard_all, OBJCOPY_discard_locals)
             ? DiscardType::All
             : DiscardType::Locals;
   Config.OnlyKeepDebug = InputArgs.hasArg(OBJCOPY_only_keep_debug);
   Config.KeepFileSymbols = InputArgs.hasArg(OBJCOPY_keep_file_symbols);
   Config.DecompressDebugSections =
       InputArgs.hasArg(OBJCOPY_decompress_debug_sections);
+  Config.UseMutableObject = InputArgs.hasArg(OBJCOPY_use_mutable_object);
   if (Config.DiscardMode == DiscardType::All)
     Config.StripDebug = true;
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbol))
     Config.SymbolsToLocalize.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_localize_symbols))
     if (Error E = addSymbolsFromFile(Config.SymbolsToLocalize, DC.Alloc,
                                      Arg->getValue(), UseRegex))
       return std::move(E);

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.h

 
 namespace elf {
 Error executeObjcopyOnIHex(const CopyConfig &Config, MemoryBuffer &In,
                            Buffer &Out);
 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
                                 Buffer &Out);
 Error executeObjcopyOnBinary(const CopyConfig &Config,
                              object::ELFObjectFileBase &In, Buffer &Out);
-
+Error executeObjcopyWithMutableObject(const CopyConfig &Config,
+                                      object::ELFObjectFileBase &In,
+                                      Buffer &Out);
 } // end namespace elf
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_ELFOBJCOPY_H

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

if (!Config.BuildIdLinkDir.empty() && Config.BuildIdLinkOutput)
     if (Error E =
             linkToBuildIdDir(Config, Config.OutputFilename,
                              Config.BuildIdLinkOutput.getValue(), BuildIdBytes))
       return createFileError(Config.OutputFilename, std::move(E));
 
   return Error::success();
 }
 
+template <typename ELFT>
+Error handleArgsAndWrite(ELFObjectFile<ELFT> *Obj, Buffer &Out) {
+  MutableELFObject<ELFT> MutableObject(std::move(*Obj));
+
+  /// TODO: handleArgs
+
+  MutableObjectWriter<ELFT> Writer(MutableObject, Out);
+  if (Error E = Writer.finalize())
+    return E;
+  return Writer.write();
+}
+
+Error executeObjcopyWithMutableObject(const CopyConfig &Config,
+                                      object::ELFObjectFileBase &In,
+                                      Buffer &Out) {
+  if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(&In))
+    return handleArgsAndWrite(O, Out);
+  else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(&In))
+    return handleArgsAndWrite(O, Out);
+  else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(&In))
+    return handleArgsAndWrite(O, Out);
+  else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(&In))
+    return handleArgsAndWrite(O, Out);
+
+  return createStringError(errc::invalid_argument, "wrong file type");
+}
+
 } // end namespace elf
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/ELF/Object.h

 #include "Buffer.h"
 #include "CopyConfig.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/MutableELFObject.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <memory>
 #include <set>
 #include <vector>

 class IHexSectionWriter : public IHexSectionWriterBase {
 public:
   IHexSectionWriter(Buffer &Buf) : IHexSectionWriterBase(Buf) {}
 
   void writeData(uint8_t Type, uint16_t Addr, ArrayRef<uint8_t> Data) override;
   void visit(const StringTableSection &Sec) override;
 };
 
-class Writer {
+struct WriterBase {
+  virtual ~WriterBase() {}
+  virtual Error finalize() = 0;
+  virtual Error write() = 0;
+};
+
+class Writer : public WriterBase {
 protected:
   Object &Obj;
   Buffer &Buf;
 
 public:
   virtual ~Writer();
-  virtual Error finalize() = 0;
-  virtual Error write() = 0;
 
   Writer(Object &O, Buffer &B) : Obj(O), Buf(B) {}
 };
 
 template <class ELFT> class ELFWriter : public Writer {
 private:
   using Elf_Addr = typename ELFT::Addr;
   using Elf_Shdr = typename ELFT::Shdr;
public:
   virtual ~ELFWriter() {}
   bool WriteSectionHeaders;
 
   Error finalize() override;
   Error write() override;
   ELFWriter(Object &Obj, Buffer &Buf, bool WSH);
 };
 
+using object::MutableELFObject;
+template <typename ELFT> class MutableObjectWriter : public WriterBase {
+  MutableELFObject<ELFT> &Obj;
+  Buffer &Buf;
+
+  Error assignOffsets();
+  Error layoutSegments(uint64_t &Offset);
+  Error layoutSections(uint64_t &Offset);
+
+  size_t totalSize();
+
+public:
+  virtual ~MutableObjectWriter() {}
+
+  Error finalize() override;
+  Error write() override;
+  MutableObjectWriter(MutableELFObject<ELFT> &Obj, Buffer &Buf)
+      : Obj(Obj), Buf(Buf) {}
+};
+
 class BinaryWriter : public Writer {
 private:
   std::unique_ptr<BinarySectionWriter> SecWriter;
 
   uint64_t TotalSize;
 
 public:
   ~BinaryWriter() {}
bool isRelocatable() const {
     return (Type != ELF::ET_DYN && Type != ELF::ET_EXEC) || MustBeRelocatable;
   }
 };
 
 } // end namespace elf
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_OBJECT_H

llvm/tools/llvm-objcopy/ELF/Object.cpp

Error IHexWriter::finalize() {
   TotalSize = LengthCalc.getBufferOffset() +
               (Obj.Entry ? IHexRecord::getLineLength(4) : 0) +
               IHexRecord::getLineLength(0);
   if (Error E = Buf.allocate(TotalSize))
     return E;
   return Error::success();
 }
 
+template <class ELFT>
+Error MutableObjectWriter<ELFT>::layoutSegments(uint64_t &Offset) {
+  using SegmentRef = typename MutableELFObject<ELFT>::SegmentRef;
+  typename ELFT::Phdr EhdrSegment;
+  EhdrSegment.p_type = PT_PHDR;
+  EhdrSegment.p_offset = 0;
+  EhdrSegment.p_flags = 0;
+  EhdrSegment.p_vaddr = 0;
+  EhdrSegment.p_align = 0;
+  EhdrSegment.p_filesz = sizeof(EhdrSegment);
+  EhdrSegment.p_memsz = sizeof(EhdrSegment);
+  typename ELFT::Phdr PhdrSegment;
+  PhdrSegment.p_type = PT_PHDR;
+  PhdrSegment.p_flags = 0;
+  PhdrSegment.p_paddr = 0;
+  PhdrSegment.p_offset = PhdrSegment.p_vaddr = Obj.getHeader().e_phoff;
+  PhdrSegment.p_align = sizeof(typename ELFT::Addr);
+  Obj.addSegment({EhdrSegment,
+                  ArrayRef<uint8_t>(Obj.base(), sizeof(typename ELFT::Ehdr)),
+                  None});
+  Obj.addSegment({PhdrSegment,
+                  ArrayRef<uint8_t>(Obj.base() + Obj.getHeader().e_phoff,
+                                    Obj.getHeader().e_phnum),
+                  None});
+  std::vector<SegmentRef> Segments(Obj.segment_begin(), Obj.segment_end());
+  PhdrSegment.p_filesz = sizeof(typename ELFT::Phdr) * Segments.size();
+  PhdrSegment.p_memsz = sizeof(typename ELFT::Phdr) * Segments.size();
+  llvm::sort(Segments, [](auto First, auto Second) {
+    return First.getHeader().p_offset < Second.getHeader().p_offset;
+  });
+
+  size_t Index = 0;
+  for (SegmentRef Segment : Obj.segments()) {
+    Optional<size_t> ParentIndex = Obj.findParentSegment(Segment);
+    auto MutPhdrOrErr = Obj.getMutableSegment(Segment);
+    if (!MutPhdrOrErr)
+      return MutPhdrOrErr.takeError();
+    if (ParentIndex == None) {
+      Offset = alignToAddr(Offset, Segment.getHeader().p_vaddr,
+                           Segment.getHeader().p_align);
+      MutPhdrOrErr->Header.p_offset = Offset;
+    } else {
+      auto ParentSegment = Obj.segment_begin();
+      std::advance(ParentSegment, *ParentIndex);
+      MutPhdrOrErr->Header.p_offset =
+          ParentSegment->getHeader().p_offset +
+          Obj.getOriginalSegment(Index).p_offset -
+          Obj.getOriginalSegment(*ParentIndex).p_offset;
+    }
+    Offset = std::max<uint64_t>(Offset, MutPhdrOrErr->Header.p_offset +
+                                            MutPhdrOrErr->Header.p_filesz);
+    ++Index;
+  }
+
+  return Error::success();
+}
+
+template <class ELFT>
+Error MutableObjectWriter<ELFT>::layoutSections(uint64_t &Offset) {
+  // Skip first section.
+  iterator_range<section_iterator> Sections(++Obj.section_begin(),
+                                            Obj.section_end());
+  for (const SectionRef Sec : Sections) {
+    Expected<MutableELFSection<ELFT> &> SecOrErr = Obj.getMutableSection(Sec);
+    if (!SecOrErr)
+      return SecOrErr.takeError();
+    MutableELFSection<ELFT> &Section = *SecOrErr;
+    if (Section.ParentIndex) {
+      auto SegmentIter = Obj.segment_begin();
+      std::advance(SegmentIter, *Section.ParentIndex);
+      Section.Header.sh_offset =
+          SegmentIter->getHeader().p_offset + Section.Header.sh_offset -
+          Obj.getOriginalSegment(*Section.ParentIndex).p_offset;
+    } else {
+      Offset = alignTo(
+          Offset, !Section.Header.sh_offset ? 1 : Section.Header.sh_offset);
+      Section.Header.sh_offset = Offset;
+      if (Section.Header.sh_type != SHT_NOBITS)
+        Offset += Section.Header.sh_size;
+    }
+  }
+
+  return Error::success();
+}
+
+template <class ELFT> Error MutableObjectWriter<ELFT>::assignOffsets() {
+  uint64_t Offset = 0;
+  if (Error E = layoutSegments(Offset))
+    return E;
+  if (Error E = layoutSections(Offset))
+    return E;
+  Offset = alignTo(Offset, sizeof(typename ELFT::Addr));
+  Obj.getMutableHeader().e_shoff = Offset;
+
+  return Error::success();
+}
+
+template <class ELFT> Error MutableObjectWriter<ELFT>::finalize() {
+  if (Error E = assignOffsets())
+    return E;
+
+  return Error::success();
+}
+
+template <class ELFT> size_t MutableObjectWriter<ELFT>::totalSize() {
+  size_t Ret = Obj.getHeader().e_shoff +
+               (std::distance(Obj.section_begin(), Obj.section_end()) *
+                sizeof(typename ELFT::Shdr));
+  return Ret;
+}
+
+template <class ELFT> Error MutableObjectWriter<ELFT>::write() {
+  if (Error E = Buf.allocate(totalSize()))
+    return E;
+
+  using SegmentRef = typename MutableELFObject<ELFT>::SegmentRef;
+  for (const SegmentRef Segment : Obj.segments()) {
+    uint8_t *Start = Buf.getBufferStart() + Segment.getHeader().p_offset;
+    Expected<MutableELFSegment<ELFT> &> MutSegment =
+        Obj.getMutableSegment(Segment);
+    if (!MutSegment)
+      return MutSegment.takeError();
+    std::memcpy(Start, MutSegment->OriginalData.data(),
+                MutSegment->OriginalData.size());
+  }
+
+  std::memcpy(Buf.getBufferStart(), &Obj.getHeader(),
+              sizeof(typename ELFT::Ehdr));
+
+  for (const SectionRef Sec : Obj.sections()) {
+    if (!Obj.findParentSegment(Sec)) {
+      Expected<MutableELFSection<ELFT> &> SecOrErr = Obj.getMutableSection(Sec);
+      if (!SecOrErr)
+        return SecOrErr.takeError();
+      uint8_t *Start = Buf.getBufferStart() + SecOrErr->Header.sh_offset;
+      std::memcpy(Start, SecOrErr->Data.data(), SecOrErr->Header.sh_size);
+    }
+  }
+
+  typename ELFT::Shdr *Shdrs = reinterpret_cast<typename ELFT::Shdr *>(
+      Buf.getBufferStart() + Obj.getHeader().e_shoff);
+  for (const SectionRef Sec : Obj.sections()) {
+    Expected<MutableELFSection<ELFT> &> SecOrErr = Obj.getMutableSection(Sec);
+    if (!SecOrErr)
+      return SecOrErr.takeError();
+    *Shdrs = SecOrErr->Header;
+    ++Shdrs;
+  }
+
+  return Buf.commit();
+}
+
 template class ELFBuilder<ELF64LE>;
 template class ELFBuilder<ELF64BE>;
 template class ELFBuilder<ELF32LE>;
 template class ELFBuilder<ELF32BE>;
 
 template class ELFWriter<ELF64LE>;
 template class ELFWriter<ELF64BE>;
 template class ELFWriter<ELF32LE>;
 template class ELFWriter<ELF32BE>;
 
+template class MutableObjectWriter<ELF64LE>;
+template class MutableObjectWriter<ELF64BE>;
+template class MutableObjectWriter<ELF32LE>;
+template class MutableObjectWriter<ELF32BE>;
+
 } // end namespace elf
 } // end namespace objcopy
 } // end namespace llvm

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

static Error executeObjcopyOnRawBinary(const CopyConfig &Config,
 
   llvm_unreachable("unsupported output format");
 }
 
 /// The function executeObjcopyOnBinary does the dispatch based on the format
 /// of the input binary (ELF, MachO or COFF).
 static Error executeObjcopyOnBinary(const CopyConfig &Config,
                                     object::Binary &In, Buffer &Out) {
-  if (auto *ELFBinary = dyn_cast<object::ELFObjectFileBase>(&In))
+  if (auto *ELFBinary = dyn_cast<object::ELFObjectFileBase>(&In)) {
+    if (Config.UseMutableObject)
+      return elf::executeObjcopyWithMutableObject(Config, *ELFBinary, Out);
     return elf::executeObjcopyOnBinary(Config, *ELFBinary, Out);
-  else if (auto *COFFBinary = dyn_cast<object::COFFObjectFile>(&In))
+  } else if (auto *COFFBinary = dyn_cast<object::COFFObjectFile>(&In))
     return coff::executeObjcopyOnBinary(Config, *COFFBinary, Out);
   else if (auto *MachOBinary = dyn_cast<object::MachOObjectFile>(&In))
     return macho::executeObjcopyOnBinary(Config, *MachOBinary, Out);
   else
     return createStringError(object_error::invalid_file_type,
                              "unsupported object file format");
 }