[llvm-objcopy][MachO] Handle relocation entries where r_extern is 0

[seiya]

Summary

As @MaskRay pointed out in D63309#1780984, a relocation entry may references a section instead of a symbol entry. This patch adds support for such relocation entries.

[seiya]

Update a comment in test. NFC.

[jhenderson]

llvm/test/tools/llvm-objcopy/MachO/copy-relocations.s

13–17

I don't think you need this comment.

28–31

I think this should go in place of the comment above.

Is it possible to use yaml to create this situation instead of assembly? Assembly is less obvious as to what you want to achieve.

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

209–210

If you don't change the Sections to unique_ptrs, you could change this to:

for (const Section &Sec : LC.Sections)
  Sections.push_back(&Sec);

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

93

Is this really necessary? As far as I can tell, the only place it's actually important is where you create a vector of section pointers, but you can do that without needing these to be unique_ptrs. I've commented above.

[seiya]

llvm/test/tools/llvm-objcopy/MachO/copy-relocations.s

28–31

Is it possible to use yaml to create this situation instead of assembly? Assembly is less obvious as to what you want to achieve.

That makes sense. AFAIK, yaml2obj does not yet support relocation entries so I'll write a patch for it first.

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

93

I think this should be unique pointers. Pointers to vector elements could be invalidated by --add-section/--remove-section operations.

[jhenderson]

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

93

Okay, that's a good point, but why wasn't it an issue already?

Assuming that it's actually important, I think moving the unique_ptr changes into a separate patch would make it more obvious what's actually important for this functional change.

[MaskRay]

llvm/test/tools/llvm-objcopy/MachO/copy-relocations.s

5

-assemble is the default action. Very few tests specify it. You can just delete it.

11

Is --macho needed?

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

220

What if r_symbolnum = 0?

[seiya]

BTW, I noticed that we need a same fix for n_sect field in nlist (in a separate patch).

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

93

Okay, that's a good point, but why wasn't it an issue already?

I think this bug has not been discovered because modifying relocatable objects that enable this feature (r_extern = 0) is a rare case.

Assuming that it's actually important, I think moving the unique_ptr changes into a separate patch would make it more obvious what's actually important for this functional change.

Moving unique_ptr changes into a separate parch sounds good to me. I'll submit it.

[seiya]

llvm/test/tools/llvm-objcopy/MachO/copy-relocations.s

11

It prints relocation fields in detail. It looks easier to read to me.

$ llvm-objdump --macho --reloc copy-relocs.o 
copy-relocs.o:
Relocation information (__DATA,__bar) 2 entries
address  pcrel length extern type    scattered symbolnum/value
00000000 False quad   False  SUB     False     3 (__DATA,__bar)
00000000 False quad   False  UNSIGND False     1 (__TEXT,__text)

$ llvm-objdump --reloc copy-relocs.o 

copy-relocs.o:  file format Mach-O 64-bit x86-64

RELOCATION RECORDS FOR [__bar]:
0000000000000000 X86_64_RELOC_SUBTRACTOR __text-__bar
0000000000000000 X86_64_RELOC_UNSIGNED __text

[MaskRay]

Ping @seiya. We need a separate patch for the for (std::unique_ptr<Section> &Sec : LC.Sections) { changes.

[alexander-shaposhnikov]

I also would like us to move forward here.
Ping @seiya, is there anything we can help you with to proceed with this patch / address @MaskRay's comments ?

[seiya]

Sorry for being too late. I have no sufficient time to work on this until the end of this month.

I'll take a look at this again later but IIRC, we need to implement relocation entries support in yaml2obj first.

[alexander-shaposhnikov]

Just in case: I've prepared a diff which adds support for relocations (for MachO) to ObjectYAML / yaml2obj / obj2yaml. I'm planning to send it for code review soon (today or tomorrow).

[seiya]

In D71647#1970793, @alexshap wrote:

Just in case: I've prepared a diff which adds support for relocations (for MachO) to ObjectYAML / yaml2obj / obj2yaml. I'm planning to send it for code review soon (today or tomorrow).

Thank you for letting me know! I'll update this diff based on yours. I haven't worked on it yet.

[alexander-shaposhnikov]

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

220

MachO section indices start from 1, not from 0, that's why (i guess) we have <= Section.size() here and -1 below.
I'd be good to add an assert that r_symbolnum > 0 in this case.

[seiya]

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

220

Yes indices starts from 1. Adding the assertion sounds good idea (btw, we need D77844 landed first since currently yaml2obj fills r_symbolnum with zeros, IIRC).

[seiya]

Fixed by @alexshap in D78946.

llvm/test/tools/llvm-objcopy/MachO/copy-relocations.s

+# REQUIRES: x86-registered-target
+
+## Show that llvm-objcopy copies relocation entries where r_extern=0.
+# RUN: llvm-mc -assemble -triple x86_64-apple-darwin19 -filetype=obj %s -o %t
+# RUN: llvm-objcopy %t %t2
+# RUN: cmp %t %t2
+
+## Show that llvm-objcopy updates section indices properly.
+# RUN: llvm-objcopy --remove-section=__DATA,__foo %t %t3
+# RUN: llvm-objdump --macho --reloc %t3 | FileCheck %s
+
+# $ llvm-objdump --macho --reloc copy-relocations.o
+# Relocation information (__DATA,__bar) 2 entries
+# address  pcrel length extern type    scattered symbolnum/value
+# 00000000 False quad   False  SUB     False     3 (__DATA,__bar)
+# 00000000 False quad   False  UNSIGND False     1 (__TEXT,__text)
+.text
+L1:
+  .quad 0
+
+.section __DATA,__foo
+  .quad 0
+
+.section __DATA,__bar
+  .quad   L1 - .
+
+# CHECK:      Relocation information (__DATA,__bar) 2 entries
+# CHECK-NEXT: address  pcrel length extern type    scattered symbolnum/value
+# CHECK-NEXT: 00000000 False quad   False  SUB     False     2 (__DATA,__bar)
+# CHECK-NEXT: 00000000 False quad   False  UNSIGND False     1 (__TEXT,__text)

llvm/tools/llvm-objcopy/MachO/MachOLayoutBuilder.cpp

if (Segname == "__LINKEDIT") {
       LinkEditLoadCommand = &MLC;
       continue;
     }
 
     // Update file offsets and sizes of sections.
     uint64_t SegOffset = Offset;
     uint64_t SegFileSize = 0;
     uint64_t VMSize = 0;
-    for (auto &Sec : LC.Sections) {
+    for (std::unique_ptr<Section> &Sec : LC.Sections) {
       if (IsObjectFile) {
-        if (Sec.isVirtualSection()) {
-          Sec.Offset = 0;
+        if (Sec->isVirtualSection()) {
+          Sec->Offset = 0;
         } else {
           uint64_t PaddingSize =
-              offsetToAlignment(SegFileSize, Align(1ull << Sec.Align));
-          Sec.Offset = SegOffset + SegFileSize + PaddingSize;
-          Sec.Size = Sec.Content.size();
-          SegFileSize += PaddingSize + Sec.Size;
+              offsetToAlignment(SegFileSize, Align(1ull << Sec->Align));
+          Sec->Offset = SegOffset + SegFileSize + PaddingSize;
+          Sec->Size = Sec->Content.size();
+          SegFileSize += PaddingSize + Sec->Size;
         }
-        VMSize = std::max(VMSize, Sec.Addr + Sec.Size);
+        VMSize = std::max(VMSize, Sec->Addr + Sec->Size);
       } else {
-        if (Sec.isVirtualSection()) {
-          Sec.Offset = 0;
-          VMSize += Sec.Size;
+        if (Sec->isVirtualSection()) {
+          Sec->Offset = 0;
+          VMSize += Sec->Size;
         } else {
-          uint32_t SectOffset = Sec.Addr - SegmentVmAddr;
-          Sec.Offset = SegOffset + SectOffset;
-          Sec.Size = Sec.Content.size();
-          SegFileSize = std::max(SegFileSize, SectOffset + Sec.Size);
+          uint32_t SectOffset = Sec->Addr - SegmentVmAddr;
+          Sec->Offset = SegOffset + SectOffset;
+          Sec->Size = Sec->Content.size();
+          SegFileSize = std::max(SegFileSize, SectOffset + Sec->Size);
           VMSize = std::max(VMSize, SegFileSize);
         }
       }
     }
 
     if (IsObjectFile) {
       Offset += SegFileSize;
     } else {
for (auto &LC : O.LoadCommands) {
     }
   }
 
   return Offset;
 }
 
 uint64_t MachOLayoutBuilder::layoutRelocations(uint64_t Offset) {
   for (auto &LC : O.LoadCommands)
-    for (auto &Sec : LC.Sections) {
-      Sec.RelOff = Sec.Relocations.empty() ? 0 : Offset;
-      Sec.NReloc = Sec.Relocations.size();
-      Offset += sizeof(MachO::any_relocation_info) * Sec.NReloc;
+    for (std::unique_ptr<Section> &Sec : LC.Sections) {
+      Sec->RelOff = Sec->Relocations.empty() ? 0 : Offset;
+      Sec->NReloc = Sec->Relocations.size();
+      Offset += sizeof(MachO::any_relocation_info) * Sec->NReloc;
     }
 
   return Offset;
 }
 
 Error MachOLayoutBuilder::layoutTail(uint64_t Offset) {
   // The order of LINKEDIT elements is as follows:
   // rebase info, binding info, weak binding info, lazy binding info, export

llvm/tools/llvm-objcopy/MachO/MachOObjcopy.cpp

 #include "llvm/Support/Errc.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace objcopy {
 namespace macho {
 
 using namespace object;
-using SectionPred = std::function<bool(const Section &Sec)>;
+using SectionPred = std::function<bool(const std::unique_ptr<Section> &Sec)>;
 
 static void removeSections(const CopyConfig &Config, Object &Obj) {
-  SectionPred RemovePred = [](const Section &) { return false; };
+  SectionPred RemovePred = [](const std::unique_ptr<Section> &) {
+    return false;
+  };
 
   if (!Config.ToRemove.empty()) {
-    RemovePred = [&Config, RemovePred](const Section &Sec) {
-      return Config.ToRemove.matches(Sec.CanonicalName);
+    RemovePred = [&Config, RemovePred](const std::unique_ptr<Section> &Sec) {
+      return Config.ToRemove.matches(Sec->CanonicalName);
     };
   }
 
   if (Config.StripAll || Config.StripDebug) {
     // Remove all debug sections.
-    RemovePred = [RemovePred](const Section &Sec) {
-      if (Sec.Segname == "__DWARF")
+    RemovePred = [RemovePred](const std::unique_ptr<Section> &Sec) {
+      if (Sec->Segname == "__DWARF")
         return true;
 
       return RemovePred(Sec);
     };
   }
 
   if (!Config.OnlySection.empty()) {
     // Overwrite RemovePred because --only-section takes priority.
-    RemovePred = [&Config](const Section &Sec) {
-      return !Config.OnlySection.matches(Sec.CanonicalName);
+    RemovePred = [&Config](const std::unique_ptr<Section> &Sec) {
+      return !Config.OnlySection.matches(Sec->CanonicalName);
     };
   }
 
   return Obj.removeSections(RemovePred);
 }
 
 static void markSymbols(const CopyConfig &Config, Object &Obj) {
   // Symbols referenced from the indirect symbol table must not be removed.
static LoadCommand buildRPathLoadCommand(StringRef Path) {
   LC.Payload.assign(RPathLC.cmdsize - sizeof(MachO::rpath_command), 0);
   std::copy(Path.begin(), Path.end(), LC.Payload.begin());
   return LC;
 }
 
 static Error dumpSectionToFile(StringRef SecName, StringRef Filename,
                                Object &Obj) {
   for (LoadCommand &LC : Obj.LoadCommands)
-    for (Section &Sec : LC.Sections) {
-      if (Sec.CanonicalName == SecName) {
+    for (std::unique_ptr<Section> &Sec : LC.Sections) {
+      if (Sec->CanonicalName == SecName) {
         Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
-            FileOutputBuffer::create(Filename, Sec.Content.size());
+            FileOutputBuffer::create(Filename, Sec->Content.size());
         if (!BufferOrErr)
           return BufferOrErr.takeError();
         std::unique_ptr<FileOutputBuffer> Buf = std::move(*BufferOrErr);
-        llvm::copy(Sec.Content, Buf->getBufferStart());
+        llvm::copy(Sec->Content, Buf->getBufferStart());
 
         if (Error E = Buf->commit())
           return E;
         return Error::success();
       }
     }
 
   return createStringError(object_error::parse_failed, "section '%s' not found",
static Error addSection(StringRef SecName, StringRef Filename, Object &Obj) {
   StringRef TargetSegName = Pair.first;
   Section Sec(TargetSegName, Pair.second);
   Sec.Content = Obj.NewSectionsContents.save(Buf->getBuffer());
 
   // Add the a section into an existing segment.
   for (LoadCommand &LC : Obj.LoadCommands) {
     Optional<StringRef> SegName = LC.getSegmentName();
     if (SegName && SegName == TargetSegName) {
-      LC.Sections.push_back(Sec);
+      LC.Sections.push_back(std::make_unique<Section>(Sec));
       return Error::success();
     }
   }
 
   // There's no segment named TargetSegName. Create a new load command and
   // Insert a new section into it.
   LoadCommand &NewSegment = Obj.addSegment(TargetSegName);
-  NewSegment.Sections.push_back(Sec);
+  NewSegment.Sections.push_back(std::make_unique<Section>(Sec));
   return Error::success();
 }
 
 // isValidMachOCannonicalName returns success if Name is a MachO cannonical name
 // ("<segment>,<section>") and lengths of both segment and section names are
 // valid.
 Error isValidMachOCannonicalName(StringRef Name) {
   if (Name.count(',') != 1)
static Error handleArgs(const CopyConfig &Config, Object &Obj) {
   // Mark symbols to determine which symbols are still needed.
   if (Config.StripAll)
     markSymbols(Config, Obj);
 
   updateAndRemoveSymbols(Config, Obj);
 
   if (Config.StripAll)
     for (LoadCommand &LC : Obj.LoadCommands)
-      for (Section &Sec : LC.Sections)
-        Sec.Relocations.clear();
+      for (std::unique_ptr<Section> &Sec : LC.Sections)
+        Sec->Relocations.clear();
 
   for (const StringRef &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 E;
   }

llvm/tools/llvm-objcopy/MachO/MachOReader.cpp

 template <> Section constructSection(MachO::section_64 Sec) {
   Section S = constructSectionCommon(Sec);
   S.Reserved3 = Sec.reserved3;
   return S;
 }
 
 // TODO: get rid of reportError and make MachOReader return Expected<> instead.
 template <typename SectionType, typename SegmentType>
-std::vector<Section>
+std::vector<std::unique_ptr<Section>>
 extractSections(const object::MachOObjectFile::LoadCommandInfo &LoadCmd,
                 const object::MachOObjectFile &MachOObj,
                 size_t &NextSectionIndex) {
   auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize;
   const SectionType *Curr =
       reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType));
-  std::vector<Section> Sections;
+  std::vector<std::unique_ptr<Section>> Sections;
   for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
     if (MachOObj.isLittleEndian() != sys::IsLittleEndianHost) {
       SectionType Sec;
       memcpy((void *)&Sec, Curr, sizeof(SectionType));
       MachO::swapStruct(Sec);
-      Sections.push_back(constructSection(Sec));
+      Sections.push_back(std::make_unique<Section>(constructSection(Sec)));
     } else {
-      Sections.push_back(constructSection(*Curr));
+      Sections.push_back(std::make_unique<Section>(constructSection(*Curr)));
     }
 
-    Section &S = Sections.back();
+    std::unique_ptr<Section> &S = Sections.back();
 
     Expected<object::SectionRef> SecRef =
         MachOObj.getSection(NextSectionIndex++);
     if (!SecRef)
       reportError(MachOObj.getFileName(), SecRef.takeError());
 
     if (Expected<ArrayRef<uint8_t>> E =
             MachOObj.getSectionContents(SecRef->getRawDataRefImpl()))
-      S.Content =
+      S->Content =
           StringRef(reinterpret_cast<const char *>(E->data()), E->size());
     else
       reportError(MachOObj.getFileName(), E.takeError());
 
-    S.Relocations.reserve(S.NReloc);
+    S->Relocations.reserve(S->NReloc);
     for (auto RI = MachOObj.section_rel_begin(SecRef->getRawDataRefImpl()),
               RE = MachOObj.section_rel_end(SecRef->getRawDataRefImpl());
          RI != RE; ++RI) {
       RelocationInfo R;
       R.Symbol = nullptr; // We'll fill this field later.
       R.Info = MachOObj.getRelocation(RI->getRawDataRefImpl());
       R.Scattered = MachOObj.isRelocationScattered(R.Info);
-      S.Relocations.push_back(R);
+      R.Extern =
+          R.Scattered ? false : MachOObj.getPlainRelocationExternal(R.Info);
+      S->Relocations.push_back(R);
     }
 
-    assert(S.NReloc == S.Relocations.size() &&
+    assert(S->NReloc == S->Relocations.size() &&
            "Incorrect number of relocations");
   }
   return Sections;
 }
 
 void MachOReader::readLoadCommands(Object &O) const {
   // For MachO sections indices start from 1.
   size_t NextSectionIndex = 1;
SymbolEntry SE =
                    StrTable,
                    MachOObj.getSymbolTableEntry(Symbol.getRawDataRefImpl())));
 
     O.SymTable.Symbols.push_back(std::make_unique<SymbolEntry>(SE));
   }
 }
 
 void MachOReader::setSymbolInRelocationInfo(Object &O) const {
+  std::vector<const Section *> Sections;
+
+  for (auto &LC : O.LoadCommands)
+    for (std::unique_ptr<Section> &Sec : LC.Sections)
+      Sections.push_back(Sec.get());
+
   for (auto &LC : O.LoadCommands)
     for (auto &Sec : LC.Sections)
-      for (auto &Reloc : Sec.Relocations)
+      for (auto &Reloc : Sec->Relocations)
         if (!Reloc.Scattered) {
           auto *Info = reinterpret_cast<MachO::relocation_info *>(&Reloc.Info);
+          if (Reloc.Extern)
             Reloc.Symbol = O.SymTable.getSymbolByIndex(Info->r_symbolnum);
+          else {
+            assert(Info->r_symbolnum <= Sections.size() &&
+                   "Invalid section index.");
+            Reloc.Section = Sections[Info->r_symbolnum - 1];
+          }
         }
 }
 
 void MachOReader::readRebaseInfo(Object &O) const {
   O.Rebases.Opcodes = MachOObj.getDyldInfoRebaseOpcodes();
 }
 
 void MachOReader::readBindInfo(Object &O) const {

llvm/tools/llvm-objcopy/MachO/MachOWriter.cpp

if (O.FunctionStartsCommandIndex) {
     if (LinkEditDataCommand.dataoff)
       Ends.push_back(LinkEditDataCommand.dataoff +
                      LinkEditDataCommand.datasize);
   }
 
   // Otherwise, use the last section / reloction.
   for (const auto &LC : O.LoadCommands)
     for (const auto &S : LC.Sections) {
-      Ends.push_back(S.Offset + S.Size);
-      if (S.RelOff)
-        Ends.push_back(S.RelOff +
-                       S.NReloc * sizeof(MachO::any_relocation_info));
+      Ends.push_back(S->Offset + S->Size);
+      if (S->RelOff)
+        Ends.push_back(S->RelOff +
+                       S->NReloc * sizeof(MachO::any_relocation_info));
     }
 
   if (!Ends.empty())
     return *std::max_element(Ends.begin(), Ends.end());
 
   // Otherwise, we have only Mach header and load commands.
   return headerSize() + loadCommandsSize();
 }
for (const auto &LC : O.LoadCommands) {
     MachO::macho_load_command MLC = LC.MachOLoadCommand;
     switch (MLC.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       if (IsLittleEndian != sys::IsLittleEndianHost)
         MachO::swapStruct(MLC.segment_command_data);
       memcpy(Begin, &MLC.segment_command_data, sizeof(MachO::segment_command));
       Begin += sizeof(MachO::segment_command);
 
-      for (const auto &Sec : LC.Sections)
-        writeSectionInLoadCommand<MachO::section>(Sec, Begin);
+      for (const std::unique_ptr<Section> &Sec : LC.Sections)
+        writeSectionInLoadCommand<MachO::section>(*Sec, Begin);
       continue;
     case MachO::LC_SEGMENT_64:
       if (IsLittleEndian != sys::IsLittleEndianHost)
         MachO::swapStruct(MLC.segment_command_64_data);
       memcpy(Begin, &MLC.segment_command_64_data,
              sizeof(MachO::segment_command_64));
       Begin += sizeof(MachO::segment_command_64);
 
-      for (const auto &Sec : LC.Sections)
-        writeSectionInLoadCommand<MachO::section_64>(Sec, Begin);
+      for (const std::unique_ptr<Section> &Sec : LC.Sections)
+        writeSectionInLoadCommand<MachO::section_64>(*Sec, Begin);
       continue;
     }
 
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
     assert(sizeof(MachO::LCStruct) + LC.Payload.size() ==                      \
            MLC.load_command_data.cmdsize);                                     \
     if (IsLittleEndian != sys::IsLittleEndianHost)                             \
void MachOWriter::writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out) {
 
   if (IsLittleEndian != sys::IsLittleEndianHost)
     MachO::swapStruct(Temp);
   memcpy(Out, &Temp, sizeof(StructType));
   Out += sizeof(StructType);
 }
 
 void MachOWriter::writeSections() {
+  uint32_t SectionIndex = 1;
   for (const auto &LC : O.LoadCommands)
-    for (const auto &Sec : LC.Sections) {
-      if (Sec.isVirtualSection())
+    for (const std::unique_ptr<Section> &Sec : LC.Sections)
+      Sec->Index = SectionIndex++;
+
+  for (const auto &LC : O.LoadCommands)
+    for (const std::unique_ptr<Section> &Sec : LC.Sections) {
+      if (Sec->isVirtualSection())
         continue;
 
-      assert(Sec.Offset && "Section offset can not be zero");
-      assert((Sec.Size == Sec.Content.size()) && "Incorrect section size");
-      memcpy(B.getBufferStart() + Sec.Offset, Sec.Content.data(),
-             Sec.Content.size());
-      for (size_t Index = 0; Index < Sec.Relocations.size(); ++Index) {
-        auto RelocInfo = Sec.Relocations[Index];
+      assert(Sec->Offset && "Section offset can not be zero");
+      assert((Sec->Size == Sec->Content.size()) && "Incorrect section size");
+      memcpy(B.getBufferStart() + Sec->Offset, Sec->Content.data(),
+             Sec->Content.size());
+      for (size_t Index = 0; Index < Sec->Relocations.size(); ++Index) {
+        auto RelocInfo = Sec->Relocations[Index];
         if (!RelocInfo.Scattered) {
           auto *Info =
               reinterpret_cast<MachO::relocation_info *>(&RelocInfo.Info);
-          Info->r_symbolnum = RelocInfo.Symbol->Index;
+          if (RelocInfo.Extern)
+            Info->r_symbolnum = (*RelocInfo.Symbol)->Index;
+          else
+            Info->r_symbolnum = (*RelocInfo.Section)->Index;
         }
 
         if (IsLittleEndian != sys::IsLittleEndianHost)
           MachO::swapStruct(
               reinterpret_cast<MachO::any_relocation_info &>(RelocInfo.Info));
-        memcpy(B.getBufferStart() + Sec.RelOff +
+        memcpy(B.getBufferStart() + Sec->RelOff +
                    Index * sizeof(MachO::any_relocation_info),
                &RelocInfo.Info, sizeof(RelocInfo.Info));
       }
     }
 }
 
 template <typename NListType>
 void writeNListEntry(const SymbolEntry &SE, bool IsLittleEndian, char *&Out,

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

struct MachHeader {
   uint32_t NCmds;
   uint32_t SizeOfCmds;
   uint32_t Flags;
   uint32_t Reserved = 0;
 };
 
 struct RelocationInfo;
 struct Section {
+  uint32_t Index;
   std::string Segname;
   std::string Sectname;
   // CanonicalName is a string formatted as “<Segname>,<Sectname>".
   std::string CanonicalName;
   uint64_t Addr = 0;
   uint64_t Size = 0;
   uint32_t Offset = 0;
   uint32_t Align = 0;
struct LoadCommand {
   // The type MachO::macho_load_command is defined in llvm/BinaryFormat/MachO.h
   // and it is a union of all the structs corresponding to various load
   // commands.
   MachO::macho_load_command MachOLoadCommand;
 
   // The raw content of the payload of the load command (located right after the
   // corresponding struct). In some cases it is either empty or can be
   // copied-over without digging into its structure.
-  std::vector<uint8_t> Payload; 
+  std::vector<uint8_t> Payload;
 
   // Some load commands can contain (inside the payload) an array of sections,
   // though the contents of the sections are stored separately. The struct
   // Section describes only sections' metadata and where to find the
   // corresponding content inside the binary.
-  std::vector<Section> Sections;
+  std::vector<std::unique_ptr<Section>> Sections;
 
   // Returns the segment name if the load command is a segment command.
   Optional<StringRef> getSegmentName() const;
 };
 
 // A symbol information. Fields which starts with "n_" are same as them in the
 // nlist.
 struct SymbolEntry {

 
 /// The location of the string table inside the binary is described by LC_SYMTAB
 /// load command.
 struct StringTable {
   std::vector<std::string> Strings;
 };
 
 struct RelocationInfo {
-  const SymbolEntry *Symbol;
+  // The referenced symbol entry. Set if !Scattered && Extern.
+  Optional<const SymbolEntry *> Symbol;
+  // The referenced section. Set if !Scattered && !Extern.
+  Optional<const Section *> Section;
   // True if Info is a scattered_relocation_info.
   bool Scattered;
+  // True if the r_symbolnum points to a section number (i.e. r_extern=0).
+  bool Extern;
   MachO::any_relocation_info Info;
 };
 
 /// The location of the rebase info inside the binary is described by
 /// LC_DYLD_INFO load command. Dyld rebases an image whenever dyld loads it at
 /// an address different from its preferred address.  The rebase information is
 /// a stream of byte sized opcodes whose symbolic names start with
 /// REBASE_OPCODE_. Conceptually the rebase information is a table of tuples:
struct Object {
   /// The index LC_FUNCTION_STARTS load comamnd if present.
   Optional<size_t> FunctionStartsCommandIndex;
 
   BumpPtrAllocator Alloc;
   StringSaver NewSectionsContents;
 
   Object() : NewSectionsContents(Alloc) {}
 
-  void removeSections(function_ref<bool(const Section &)> ToRemove);
+  void
+  removeSections(function_ref<bool(const std::unique_ptr<Section> &)> ToRemove);
   void addLoadCommand(LoadCommand LC);
 
   /// Creates a new segment load command in the object and returns a reference
   /// to the newly created load command. The caller should verify that SegName
   /// is not too long (SegName.size() should be less than or equal to 16).
   LoadCommand &addSegment(StringRef SegName);
 
   bool is64Bit() const {

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

 
 void SymbolTable::removeSymbols(
     function_ref<bool(const std::unique_ptr<SymbolEntry> &)> ToRemove) {
   Symbols.erase(
       std::remove_if(std::begin(Symbols), std::end(Symbols), ToRemove),
       std::end(Symbols));
 }
 
-void Object::removeSections(function_ref<bool(const Section &)> ToRemove) {
+void Object::removeSections(
+    function_ref<bool(const std::unique_ptr<Section> &)> ToRemove) {
   for (LoadCommand &LC : LoadCommands)
     LC.Sections.erase(std::remove_if(std::begin(LC.Sections),
                                      std::end(LC.Sections), ToRemove),
                       std::end(LC.Sections));
 }
 
 void Object::addLoadCommand(LoadCommand LC) {
   LoadCommands.push_back(std::move(LC));
LoadCommand &Object::addSegment(StringRef SegName) {
   LoadCommand LC;
   if (is64Bit())
     constructSegment(LC.MachOLoadCommand.segment_command_64_data,
                      MachO::LC_SEGMENT_64, SegName);
   else
     constructSegment(LC.MachOLoadCommand.segment_command_data,
                      MachO::LC_SEGMENT, SegName);
 
-  LoadCommands.push_back(LC);
+  LoadCommands.push_back(std::move(LC));
   return LoadCommands.back();
 }
 
 /// Extracts a segment name from a string which is possibly non-null-terminated.
 static StringRef extractSegmentName(const char *SegName) {
   return StringRef(SegName,
                    strnlen(SegName, sizeof(MachO::segment_command::segname)));
 }