[llvm-objcopy] Add --update-section

[evgeny777]

Summary

This patch adds --update-section option which is present in GNU objcopy. It's being occasionally used for hacking/binary patching tasks.

[jhenderson]

I suspect that this is going to interact nastily with D59483. Does GNU objcopy support updating sections within segments?

tools/llvm-objcopy/ObjcopyOpts.td

260

Add, append to or replace the section contents? Adding doesn't make sense if the switch is called update-section...

[evgeny777]

I suspect that this is going to interact nastily with D59843.

Sorry, can't find this patch. What's this?

Does GNU objcopy support updating sections within segments?

Yep. Here is RFC https://binutils.sourceware.narkive.com/LI0gnMHb/rfc-objcopy-add-update-section-option.

tools/llvm-objcopy/ObjcopyOpts.td

260

s/Add/Update/g

[jhenderson]

In D59351#1433075, @evgeny777 wrote:

I suspect that this is going to interact nastily with D59843.

Sorry, can't find this patch. What's this?

Oops typo (now fixed). It should be D59483.

Does GNU objcopy support updating sections within segments?

Yep. Here is RFC https://binutils.sourceware.narkive.com/LI0gnMHb/rfc-objcopy-add-update-section-option.

Okay, thanks. I'll take a look at that.

[rupprecht]

tools/llvm-objcopy/ELF/Object.cpp

781

@pcc has a similar change for this: D58426

I didn't totally grep that change either, but since you've independently come to the same conclusion, something like this is probably correct.

tools/llvm-objcopy/ELF/Object.h

322

*Sections.rbegin() is slightly simpler

[jakehehrlich]

Rather than updating a section in place we should extend the "replaceSectionReferences" method to work in every section type, and then swap the object out for a new object rather than updating in place.

[jakehehrlich]

tools/llvm-objcopy/ELF/Object.cpp

783

We need to be *very* careful here. Can you explain why you did this?

1489

We should not be changing segment layout. This is a huge bag of worms and this function does not correctly handle this. You basically have to re-link an executable to do this. Changing the size of a section that's within a segment should just simply be an error. I'm highly skeptical of use cases that require this.

[evgeny777]

tools/llvm-objcopy/ELF/Object.cpp

783

This patch introduces segment fixup procedure which works incorrectly without this change
Besides that this change has some sense, because:

• Non-allocatable section can't be in segment
• Using MemSize instead of FileSize seems correct, because some allocatable sections (like .bss) have file size of 0.

1489

One of use cases is adding some initialization to existing binary, e.g you dump text section and your own function, change start address, write section back to the module. There are other use cases as well:

https://github.com/hioa-cs/IncludeOS/blob/master/cmake/post.service.cmake
https://github.com/torvalds/linux/blob/master/arch/mips/Kconfig
https://github.com/abelromeroperez/underc0rerk/blob/master/patch-lkm.py

Also see RFC

[pcc]

tools/llvm-objcopy/ELF/Object.cpp

783

For sections such as bss, sh_offset can have an arbitrary value (because there is no file data), so this can end up returning the wrong result. To properly classify bss sections, sh_addr must be used as in D58426.

[AsafFisher]

What's up with this PR? What happens if the section size increases? Where do you handle the fixing of the .bss section?

[AsafFisher]

What's up with this PR?

tools/llvm-objcopy/ELF/Object.cpp

783

Seems like D58426 is done, rebase!

1489

Lets make this work, GNU binutils implements it.

[evgeny777]

@AsafFisher I don't have time for this ATM. Feel free to take over.
Probably you can simplify this patch, so it doesn't touch segments

[AsafFisher]

GNU’s objcopy touches segments why don’t we?

test/tools/llvm-objcopy/ELF/update-section.test

+# RUN: yaml2obj %s -o %t
+
+# Update segment section with a larger chunk of data. We should recalculate offsets of
+# all following sections, including ones residing in another segments. We also should
+# update segment offset when neeeded. We don't touch section addresses, because this
+# doesn't make sense neither for relocatable object nor for final image.
+# RUN: echo -n 1111222233334444 > %t.text
+# RUN: llvm-objcopy --update-section=.text=%t.text %t %t2
+# RUN: llvm-readobj --section-headers --section-data --program-headers %t2 | FileCheck %s --check-prefix=LONG
+
+# Update to original contents after another update should give us the
+# original result.
+# RUN: echo -n 00000000 > %t2.text
+# RUN: llvm-objcopy %t %t3
+# RUN: llvm-objcopy --update-section=.text=%t.text --update-section=.text=%t2.text %t %t4
+# RUN: cmp %t3 %t4
+
+# Update segment section with a smaller chunk of data. Offsets are not recalculated in this case.
+# RUN: echo -n 00 > %t3.text
+# RUN: llvm-objcopy --update-section=.text=%t3.text %t %t5
+# RUN: llvm-readobj --section-headers --section-data --program-headers %t5 | FileCheck %s --check-prefix=SHORT
+
+# We can't update sections which don't exist
+# RUN: not llvm-objcopy --update-section=.nosection=%t.text %t3 %t-err1 2>&1 | FileCheck %s --check-prefix=ERR1
+
+# We can't update certain types of sections
+# RUN: not llvm-objcopy --update-section=.symtab=%t.text %t3 %t-err2 2>&1 | FileCheck %s --check-prefix=ERR2
+# RUN: not llvm-objcopy --update-section=.bss=%t.text %t3 %t-err2 2>&1 | FileCheck %s --check-prefix=ERR3
+
+!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:    0x8
+    Content:         "3030303030303030"
+  - Name:            .init
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Content:         "00000000"
+    Address:         0x1008
+    AddressAlign:    0x8
+  - Name:            .data
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC ]
+    Content:         "3030303030303030"
+    Address:         0x1010
+    AddressAlign:    0x8
+  - Name:            .bss
+    Type:            SHT_NOBITS
+    Flags:           [ SHF_ALLOC ]
+    Size:            0x8
+    Address:         0x1018
+    AddressAlign:    0x8
+ProgramHeaders:
+  - Type: PT_LOAD
+    Flags: [ PF_X, PF_R ]
+    VAddr: 0x1000
+    PAddr: 0x1000
+    Align: 0x1000
+    Sections:
+      - Section: .text
+      - Section: .init
+  - Type: PT_LOAD
+    Flags: [ PF_R ]
+    VAddr: 0x2010
+    PAddr: 0x2010
+    Align: 0x1000
+    Sections:
+      - Section: .data
+      - Section: .bss
+
+# LONG:   Name: .text
+# LONG:   Address: 0x1000
+# LONG:   Offset: 0x1000
+# LONG:   Size: 16
+# LONG:   |1111222233334444|
+# LONG:   Name: .init
+# LONG:   Address: 0x1008
+# LONG:   Offset: 0x1010
+# LONG:   Size: 4
+# LONG:   Name: .data
+# LONG:   Address: 0x1010
+# LONG:   Offset: 0x2010
+# LONG:   Size: 8
+# LONG:       ProgramHeaders [
+# LONG-NEXT:    ProgramHeader {
+# LONG-NEXT:    Type: PT_LOAD (0x1)
+# LONG-NEXT:    Offset: 0x1000
+# LONG-NEXT:    VirtualAddress: 0x1000
+# LONG-NEXT:    PhysicalAddress: 0x1000
+# LONG-NEXT:    FileSize: 20
+# LONG-NEXT:    MemSize: 20
+# LONG-NEXT:    Flags [ (0x5)
+# LONG-NEXT:      PF_R (0x4)
+# LONG-NEXT:      PF_X (0x1)
+# LONG-NEXT:    ]
+# LONG-NEXT:    Alignment: 4096
+# LONG-NEXT:  }
+# LONG-NEXT:  ProgramHeader {
+# LONG-NEXT:    Type: PT_LOAD (0x1)
+# LONG-NEXT:    Offset: 0x2010
+# LONG-NEXT:    VirtualAddress: 0x2010
+# LONG-NEXT:    PhysicalAddress: 0x2010
+# LONG-NEXT:    FileSize: 8
+# LONG-NEXT:    MemSize: 16
+# LONG-NEXT:    Flags [ (0x4)
+# LONG-NEXT:      PF_R (0x4)
+# LONG-NEXT:    ]
+# LONG-NEXT:    Alignment: 4096
+# LONG-NEXT:  }
+# LONG-NEXT: ]
+
+# SHORT:   Name: .text
+# SHORT:   Address: 0x1000
+# SHORT:   Offset: 0x1000
+# SHORT:   Size: 2
+# SHORT:   |00|
+# SHORT:   Name: .init
+# SHORT:   Address: 0x1008
+# SHORT:   Offset: 0x1008
+# SHORT:   Size: 4
+# SHORT:   Name: .data
+# SHORT:   Address: 0x1010
+# SHORT:   Offset: 0x1010
+# SHORT:   Size: 8
+# SHORT:      ProgramHeaders [
+# SHORT-NEXT:    ProgramHeader {
+# SHORT-NEXT:    Type: PT_LOAD (0x1)
+# SHORT-NEXT:    Offset: 0x1000
+# SHORT-NEXT:    VirtualAddress: 0x1000
+# SHORT-NEXT:    PhysicalAddress: 0x1000
+# SHORT-NEXT:    FileSize: 12
+# SHORT-NEXT:    MemSize: 12
+# SHORT-NEXT:    Flags [ (0x5)
+# SHORT-NEXT:      PF_R (0x4)
+# SHORT-NEXT:      PF_X (0x1)
+# SHORT-NEXT:    ]
+# SHORT-NEXT:    Alignment: 4096
+# SHORT-NEXT:  }
+# SHORT-NEXT:  ProgramHeader {
+# SHORT-NEXT:    Type: PT_LOAD (0x1)
+# SHORT-NEXT:    Offset: 0x1010
+# SHORT-NEXT:    VirtualAddress: 0x2010
+# SHORT-NEXT:    PhysicalAddress: 0x2010
+# SHORT-NEXT:    FileSize: 8
+# SHORT-NEXT:    MemSize: 16
+# SHORT-NEXT:    Flags [ (0x4)
+# SHORT-NEXT:      PF_R (0x4)
+# SHORT-NEXT:    ]
+# SHORT-NEXT:    Alignment: 4096
+# SHORT-NEXT:  }
+# SHORT-NEXT: ]
+
+# ERR1: error: Section '.nosection' not found
+# ERR2: error: Section '.symtab' can't be updated
+# ERR3: error: Section '.bss' can't be updated

tools/llvm-objcopy/CopyConfig.h

struct CopyConfig {
   Optional<StringRef> BuildIdLinkInput;
   Optional<StringRef> BuildIdLinkOutput;
   StringRef SplitDWO;
   StringRef SymbolsPrefix;
   DiscardType DiscardMode = DiscardType::None;
 
   // Repeated options
   std::vector<StringRef> AddSection;
+  std::vector<StringRef> UpdateSection;
   std::vector<StringRef> DumpSection;
   std::vector<NewSymbolInfo> SymbolsToAdd;
   std::vector<NameOrRegex> KeepSection;
   std::vector<NameOrRegex> OnlySection;
   std::vector<NameOrRegex> SymbolsToGlobalize;
   std::vector<NameOrRegex> SymbolsToKeep;
   std::vector<NameOrRegex> SymbolsToLocalize;
   std::vector<NameOrRegex> SymbolsToRemove;

tools/llvm-objcopy/CopyConfig.cpp

Expected<DriverConfig> parseObjcopyOptions(ArrayRef<const char *> ArgsArr) {
   for (auto Arg : InputArgs.filtered(OBJCOPY_remove_section))
     Config.ToRemove.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_keep_section))
     Config.KeepSection.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_only_section))
     Config.OnlySection.emplace_back(Arg->getValue(), UseRegex);
   for (auto Arg : InputArgs.filtered(OBJCOPY_add_section))
     Config.AddSection.push_back(Arg->getValue());
+  for (auto Arg : InputArgs.filtered(OBJCOPY_update_section))
+    Config.UpdateSection.push_back(Arg->getValue());
   for (auto Arg : InputArgs.filtered(OBJCOPY_dump_section))
     Config.DumpSection.push_back(Arg->getValue());
   Config.StripAll = InputArgs.hasArg(OBJCOPY_strip_all);
   Config.StripAllGNU = InputArgs.hasArg(OBJCOPY_strip_all_gnu);
   Config.StripDebug = InputArgs.hasArg(OBJCOPY_strip_debug);
   Config.StripDWO = InputArgs.hasArg(OBJCOPY_strip_dwo);
   Config.StripSections = InputArgs.hasArg(OBJCOPY_strip_sections);
   Config.StripNonAlloc = InputArgs.hasArg(OBJCOPY_strip_non_alloc);

tools/llvm-objcopy/ELF/ELFObjcopy.cpp

 }
 
 static bool isUnneededSymbol(const Symbol &Sym) {
   return !Sym.Referenced &&
          (Sym.Binding == STB_LOCAL || Sym.getShndx() == SHN_UNDEF) &&
          Sym.Type != STT_FILE && Sym.Type != STT_SECTION;
 }
 
+static Error
+handleUserSection(StringRef Flag,
+                  std::function<Error(StringRef, ArrayRef<uint8_t>)> F) {
+  std::pair<StringRef, StringRef> SecPair = Flag.split("=");
+  StringRef SecName = SecPair.first;
+  StringRef File = SecPair.second;
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr = MemoryBuffer::getFile(File);
+  if (!BufOrErr)
+    return createFileError(File, errorCodeToError(BufOrErr.getError()));
+  std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
+  ArrayRef<uint8_t> Data(
+      reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
+      Buf->getBufferSize());
+  return F(SecName, Data);
+}
+
 // This function handles the high level operations of GNU objcopy including
 // handling command line options. It's important to outline certain properties
 // we expect to hold of the command line operations. Any operation that "keeps"
 // should keep regardless of a remove. Additionally any removal should respect
 // any previous removals. Lastly whether or not something is removed shouldn't
 // depend a) on the order the options occur in or b) on some opaque priority
 // system. The only priority is that keeps/copies overrule removes.
 static Error handleArgs(const CopyConfig &Config, Object &Obj,
for (auto &Sec : Obj.sections()) {
       if (Iter != Config.SetSectionFlags.end()) {
         const SectionFlagsUpdate &SFU = Iter->second;
         Sec.Flags = setSectionFlagsPreserveMask(Sec.Flags, SFU.NewFlags);
       }
     }
   }
   
   for (const auto &Flag : Config.AddSection) {
-    std::pair<StringRef, StringRef> SecPair = Flag.split("=");
-    StringRef SecName = SecPair.first;
-    StringRef File = SecPair.second;
-    ErrorOr<std::unique_ptr<MemoryBuffer>> BufOrErr =
-        MemoryBuffer::getFile(File);
-    if (!BufOrErr)
-      return createFileError(File, errorCodeToError(BufOrErr.getError()));
-    std::unique_ptr<MemoryBuffer> Buf = std::move(*BufOrErr);
-    ArrayRef<uint8_t> Data(
-        reinterpret_cast<const uint8_t *>(Buf->getBufferStart()),
-        Buf->getBufferSize());
+    auto AddSection = [&](StringRef Name, ArrayRef<uint8_t> Data) {
       OwnedDataSection &NewSection =
-        Obj.addSection<OwnedDataSection>(SecName, Data);
-    if (SecName.startswith(".note") && SecName != ".note.GNU-stack")
+          Obj.addSection<OwnedDataSection>(Name, Data);
+      if (Name.startswith(".note") && Name != ".note.GNU-stack")
         NewSection.Type = SHT_NOTE;
+      return Error::success();
+    };
+    if (Error E = handleUserSection(Flag, AddSection))
+      return E;
+  }
+
+  for (const auto &Flag : Config.UpdateSection) {
+    auto UpdateSection = [&](StringRef Name, ArrayRef<uint8_t> Data) {
+      return Obj.updateSection(Name, Data);
+    };
+    if (Error E = handleUserSection(Flag, UpdateSection))
+      return E;
   }
 
   for (const auto &Flag : Config.DumpSection) {
     std::pair<StringRef, StringRef> SecPair = Flag.split("=");
     StringRef SecName = SecPair.first;
     StringRef File = SecPair.second;
     if (Error E = dumpSectionToFile(SecName, File, Obj))
       return createFileError(Config.InputFilename, std::move(E));

tools/llvm-objcopy/ELF/Object.h

public:
   virtual Error
   removeSectionReferences(function_ref<bool(const SectionBase *)> ToRemove);
   virtual Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove);
   virtual void accept(SectionVisitor &Visitor) const = 0;
   virtual void accept(MutableSectionVisitor &Visitor) = 0;
   virtual void markSymbols();
   virtual void
   replaceSectionReferences(const DenseMap<SectionBase *, SectionBase *> &);
+  virtual bool isReplaceable() const { return false; }
 };
 
 class Segment {
 private:
   struct SectionCompare {
     bool operator()(const SectionBase *Lhs, const SectionBase *Rhs) const {
       // Some sections might have the same address if one of them is empty. To
       // fix this we can use the lexicographic ordering on ->Addr and the
       // address of the actully stored section.
       if (Lhs->OriginalOffset == Rhs->OriginalOffset)
         return Lhs < Rhs;
       return Lhs->OriginalOffset < Rhs->OriginalOffset;
     }
   };
 
-  std::set<const SectionBase *, SectionCompare> Sections;
+  std::set<SectionBase *, SectionCompare> Sections;
 
 public:
   uint32_t Type;
   uint32_t Flags;
   uint64_t Offset;
   uint64_t VAddr;
   uint64_t PAddr;
   uint64_t FileSize;
   uint64_t MemSize;
   uint64_t Align;
 
   uint32_t Index;
   uint64_t OriginalOffset;
   Segment *ParentSegment = nullptr;
 
   const SectionBase *firstSection() const {
-    if (!Sections.empty())
-      return *Sections.begin();
-    return nullptr;
+    return Sections.empty() ? nullptr : *Sections.begin();
   }
 
-  void removeSection(const SectionBase *Sec) { Sections.erase(Sec); }
-  void addSection(const SectionBase *Sec) { Sections.insert(Sec); }
+  const SectionBase *lastSection() const {
+    return Sections.empty() ? nullptr : *(--Sections.end());
+  }
+
+  void fixupSectionOffsets();
+  void removeSection(SectionBase *Sec) { Sections.erase(Sec); }
+  void addSection(SectionBase *Sec) { Sections.insert(Sec); }
 };
 
 class Section : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
   ArrayRef<uint8_t> Contents;
   SectionBase *LinkSection = nullptr;
 
 public:
   explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
 
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
   Error removeSectionReferences(
       function_ref<bool(const SectionBase *)> ToRemove) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
+  bool isReplaceable() const override { return Type != ELF::SHT_NOBITS; }
 };
 
 class OwnedDataSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
   std::vector<uint8_t> Data;
 
 public:
   OwnedDataSection(StringRef SecName, ArrayRef<uint8_t> Data)
       : Data(std::begin(Data), std::end(Data)) {
     Name = SecName.str();
     Type = ELF::SHT_PROGBITS;
     Size = Data.size();
     OriginalOffset = std::numeric_limits<uint64_t>::max();
   }
 
+  OwnedDataSection(SectionBase &S, ArrayRef<uint8_t> Data)
+      : SectionBase(S), Data(std::begin(Data), std::end(Data)) {
+    Size = Data.size();
+  }
+
   void accept(SectionVisitor &Sec) const override;
   void accept(MutableSectionVisitor &Visitor) override;
+  bool isReplaceable() const override { return true; }
 };
 
 class CompressedSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 
   DebugCompressionType CompressionType;
   uint64_t DecompressedSize;
   uint64_t DecompressedAlign;
template <class T, class... Ts> T &addSection(Ts &&... Args) {
     Sections.emplace_back(std::move(Sec));
     Ptr->Index = Sections.size();
     return *Ptr;
   }
   Segment &addSegment() {
     Segments.emplace_back(llvm::make_unique<Segment>());
     return *Segments.back();
   }
+  Error updateSection(StringRef Name, ArrayRef<uint8_t> Data);
 };
 
 } // end namespace elf
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_OBJCOPY_OBJECT_H

tools/llvm-objcopy/ELF/Object.cpp

 // Returns true IFF a section is wholly inside the range of a segment
 static bool sectionWithinSegment(const SectionBase &Section,
                                  const Segment &Segment) {
   // If a section is empty it should be treated like it has a size of 1. This is
   // to clarify the case when an empty section lies on a boundary between two
   // segments and ensures that the section "belongs" to the second segment and
   // not the first.
   uint64_t SecSize = Section.Size ? Section.Size : 1;
-  return Segment.Offset <= Section.OriginalOffset &&
-         Segment.Offset + Segment.FileSize >= Section.OriginalOffset + SecSize;
+  return (Section.Flags & ELF::SHF_ALLOC) &&
+         Segment.Offset <= Section.OriginalOffset &&
+         Segment.Offset + Segment.MemSize >= Section.OriginalOffset + SecSize;
 }
 
 // Returns true IFF a segment's original offset is inside of another segment's
 // range.
 static bool segmentOverlapsSegment(const Segment &Child,
                                    const Segment &Parent) {
 
   return Parent.OriginalOffset <= Child.OriginalOffset &&
void Object::sortSections() {
   // possible while meeting that demand however.
   auto CompareSections = [](const SecPtr &A, const SecPtr &B) {
     return A->OriginalOffset < B->OriginalOffset;
   };
   std::stable_sort(std::begin(this->Sections), std::end(this->Sections),
                    CompareSections);
 }
 
+Error Object::updateSection(StringRef Name, ArrayRef<uint8_t> Data) {
+  auto It = llvm::find_if(Sections,
+                          [&](const SecPtr &Sec) { return Sec->Name == Name; });
+  if (It == Sections.end())
+    return createStringError(errc::invalid_argument, "Section '%s' not found.",
+                             Name.str().c_str());
+  if (!(*It)->isReplaceable())
+    return createStringError(errc::invalid_argument,
+                             "Section '%s' can't be updated.",
+                             Name.str().c_str());
+
+  auto *OldSec = It->get();
+  *It = llvm::make_unique<OwnedDataSection>(*OldSec, Data);
+  // Update segment section list if needed.
+  if (auto *Seg = (*It)->ParentSegment) {
+    Seg->removeSection(OldSec);
+    Seg->addSection(It->get());
+  }
+  return Error::success();
+}
+
 static uint64_t alignToAddr(uint64_t Offset, uint64_t Addr, uint64_t Align) {
   // Calculate Diff such that (Offset + Diff) & -Align == Addr & -Align.
   if (Align == 0)
     Align = 1;
   auto Diff =
       static_cast<int64_t>(Addr % Align) - static_cast<int64_t>(Offset % Align);
   // We only want to add to Offset, however, so if Diff < 0 we can add Align and
   // (Offset + Diff) & -Align == Addr & -Align will still hold.
if (Segment->ParentSegment != nullptr) {
       Offset = alignToAddr(Offset, Segment->VAddr, Segment->Align);
       Segment->Offset = Offset;
     }
     Offset = std::max(Offset, Segment->Offset + Segment->FileSize);
   }
   return Offset;
 }
 
+// We could have inserted a section of larger size when processing
+// --update-sections. In such case we should update section offsets within a
+// segment. Offset of first section in a segment will be calculated later in
+// layoutSections based on segment virtual address and previous segment size.
+void Segment::fixupSectionOffsets() {
+  SectionBase *Prev = nullptr;
+  for (auto *Sec : Sections) {
+    if (Prev == nullptr) {
+      Prev = Sec;
+      continue;
+    }
+    uint64_t PrevSize = Prev->Type == ELF::SHT_NOBITS ? 0 : Prev->Size;
+    Sec->Offset = std::max(Sec->Offset, alignTo(Prev->Offset + PrevSize,
+                                                Sec->Align ? Sec->Align : 1));
+    Prev = Sec;
+  }
+}
+
+// Fixup segments in case --update-section caused section to be replaced with
+// a section of larger size. In such case we have to update both section offsets
+// and segment sizes.
+template <class Range> static void fixupSegments(Range &Segments) {
+  for (auto &Seg : Segments) {
+    Seg->fixupSectionOffsets();
+    if (const SectionBase *LastSec = Seg->lastSection()) {
+      Seg->MemSize =
+          std::max(Seg->MemSize, LastSec->Offset + LastSec->Size - Seg->Offset);
+      Seg->FileSize = std::max(Seg->FileSize, LastSec->Type == SHT_NOBITS
+                                                  ? Seg->MemSize - LastSec->Size
+                                                  : Seg->MemSize);
+    }
+  }
+}
+
 // This function finds a consistent layout for a list of sections. It assumes
 // that the ->ParentSegment of each section has already been laid out. The
 // supplied starting Offset is used for the starting offset of any section that
 // does not have a ParentSegment. It returns either the offset given if all
 // sections had a ParentSegment or an offset one past the last section if there
 // was a section that didn't have a ParentSegment.
 template <class Range>
 static uint64_t layoutSections(Range Sections, uint64_t Offset) {
   // Now the offset of every segment has been set we can assign the offsets
   // of each section. For sections that are covered by a segment we should use
   // the segment's original offset and the section's original offset to compute
   // the offset from the start of the segment. Using the offset from the start
   // of the segment we can assign a new offset to the section. For sections not
   // covered by segments we can just bump Offset to the next valid location.
   uint32_t Index = 1;
   for (auto &Section : Sections) {
     Section.Index = Index++;
     if (Section.ParentSegment != nullptr) {
       auto Segment = *Section.ParentSegment;
       Section.Offset =
-          Segment.Offset + (Section.OriginalOffset - Segment.OriginalOffset);
+          Segment.Offset + (Section.Offset - Segment.OriginalOffset);
     } else {
       Offset = alignTo(Offset, Section.Align == 0 ? 1 : Section.Align);
       Section.Offset = Offset;
       if (Section.Type != SHT_NOBITS)
         Offset += Section.Size;
     }
   }
   return Offset;
template <class ELFT> void ELFWriter<ELFT>::assignOffsets() {
   // so that we know that anytime ->ParentSegment is set that segment has
   // already had its offset properly set.
   std::vector<Segment *> OrderedSegments;
   for (auto &Segment : Obj.segments())
     OrderedSegments.push_back(&Segment);
   OrderedSegments.push_back(&Obj.ElfHdrSegment);
   OrderedSegments.push_back(&Obj.ProgramHdrSegment);
   orderSegments(OrderedSegments);
+  // Fix segment sizes and section offsets within segment.
+  fixupSegments(OrderedSegments);
   // Offset is used as the start offset of the first segment to be laid out.
   // Since the ELF Header (ElfHdrSegment) must be at the start of the file,
   // we start at offset 0.
   uint64_t Offset = 0;
   Offset = LayoutSegments(OrderedSegments, Offset);
   Offset = layoutSections(Obj.sections(), Offset);
   // If we need to write the section header table out then we need to align the
   // Offset so that SHOffset is valid.

tools/llvm-objcopy/ObjcopyOpts.td

 
 defm add_symbol
     : Eq<"add-symbol", "Add new symbol <name> to .symtab. Accepted flags: "
          "global, local, weak, default, hidden, file, section, object, "
          "function, indirect-function. Accepted but ignored for "
          "compatibility: debug, constructor, warning, indirect, synthetic, "
          "unique-object, before.">,
       MetaVarName<"name=[section:]value[,flags]">;
+
+defm update_section
+    : Eq<"update-section", "Add section <name> with contents from a file <file>.">,
+      MetaVarName<"name=file">;