[llvm-objcopy][MachO] Support load commands used in executables/shared libraries

[seiya]

Summary

This patch implements copying some load commands that appear in executables/shared libraries such as the indirect symbol table.

I don't add tests intentionally because this patch is incomplete: we need a layout algorithm for executables/shared libraries. I'll submit it as a separate patch with tests.

[jhenderson]

I've subscribed @mtrent, who I believe is Mach-O experienced (sorry if I'm wrong!). He might be able to assist with the review more.

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

60

which employed -> which are employed

(I think)

[MaskRay]

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

227

This can be written as: arrayRefFromStringRef(MachOObj.getData().substr(...));

240

arrayRefFromStringRef

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

455

emplace_back saves a pair of {}.

[seiya]

• Fix a comment.
• Use arrayRefFromStringRef.
• Use emplace_back.

[alexander-shaposhnikov]

sorry about the delay with the review, I've been (and probably will be over the next few weeks) quite busy recently, but I'll take a closer look at the diff tomorrow.

[alexander-shaposhnikov]

Regarding tests - even without computing the new layout - could we add a test which simply copies a .so and verifies that the output is the same ?

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

244

maybe

++i

[alexander-shaposhnikov]

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

28

so after some thinking about what's going on here it seems to me
maybe it's possible to move the logic for building the layout from MachOWriter into a separate class MachOLayoutBuilder, basically it's motivated by "separation of concerns" / desire to simplify a bit what's going on here. Roughly speaking the idea is the following:

1. MachOLayoutBuilder will take the model (Object) and update all the offsets / sizes. In particular, it might hold some additional state internally (like MachO::macho_load_command *LinkEditLoadCommand) and will be responsible for calling the private subroutines (computeSizeOfCmds, layoutSegments, layoutRelocations, updateDySymTab, layoutTail) in the correct order, etc. The contract here is that after calling its public method build() the layout is final and one can safely use it to calculate / get the total size of the binary, all the offsets/sizes are valid etc.

2. MachOWriter will be responsible for managing the Buffer + writing things into it properly, but it will never modify the model (Object) directly (but internally it can make use of MachOLayoutBuilder before writing things out).

What do you think ?

[alexander-shaposhnikov]

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

28

in 2. i meant that it would not modify the offsets/sizes directly.

In general, i don't insist on this approach since things are quite complex here, we have to update / rebuild many other things besides the offsets/sizes. If we could split out that logic - that would be cool imo / it would enable us to unload some complexity from the writer, this was the main point of my comment.

[seiya]

I'll separate the layout logic into a new class: MachOLayoutBuilder

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

28

That sounds good to me. I'll try isolating the layout logic into a separate class.

[seiya]

• Isolate the logic which modifies the object (e.g. updating file offsets) into MachOLayoutBuilder.cpp

[seiya]

Ah, should MachOLayoutBuilder be a separate NFC patch?

[seiya]

Ping

[seiya]

Ping!

[seiya]

Ping

[alexander-shaposhnikov]

sorry about the delay, will get to these reviews today

[alexander-shaposhnikov]

it's simply a very very busy season

[alexander-shaposhnikov]

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

61 ↗

(On Diff #205936)

I'd be defensive here: add an assert/logical check (for example, via std::is_sorted + custom comparator)
+ probably we probably need to actually sort at some point, don't we ?

75 ↗

(On Diff #205936)

nit: ++Iter

79 ↗

(On Diff #205936)

nit: ++NumExtDefSymbols

[alexander-shaposhnikov]

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

55 ↗

(On Diff #205936)

Symbol->Index = Index++;

75 ↗

(On Diff #205936)

and the same above

[seiya]

Addressed review comments.

[seiya]

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

61 ↗

(On Diff #205936)

Yes we will need to sort symbols when we support adding symbols.

[seiya]

Thank you for your review comments, @alexshap! I've updated the patch.

[alexander-shaposhnikov]

the code looks good to me, but we need tests. I'd add simple tests which take YAML (similarly to how the existing tests work), generate MachO (using yaml2obj), copy it using llvm-objcopy,
dump the results (using llvm-readobj and obj2yamal) and verify that the output is what we expect. Plus those tools will parse the binary generated by llvm-objcopy thus they will verify (to some extent) that we have built a valid MachO object file.

[seiya]

In D63395#1598087, @alexshap wrote:

the code looks good to me, but we need tests. I'd add simple tests which take YAML (similarly to how the existing tests work), generate MachO (using yaml2obj), copy it using llvm-objcopy,
dump the results (using llvm-readobj and obj2yamal) and verify that the output is what we expect. Plus those tools will parse the binary generated by llvm-objcopy thus they will verify (to some extent) that we have built a valid MachO object file.

I'd like to add tests in the next (and the last piece for executable support) patch which implements layout algorithm for executables/shared libraries. This patch focuses on copying some load commands (LC_DYSYMTAB, etc.) that are used in them.

[seiya]

Because this patch does not include any tests, I'll commit it once the next patch (which I'll upload tomorrow) gets accepted.

[seiya]

Rebase for the sake of arc patch.

[seiya]

I've reverted this patch due to the CI build breakage on sanitizer-x86_64-linux-gn.

[seiya]

Ah, it looks this broke because it adds a new file to CMakeLists.txt. Just confirm, can I ignore such breakage? It will be resolved by a "gn build: Merge ..." commit.

[jhenderson]

In D63395#1634793, @seiya wrote:

Ah, it looks this broke because it adds a new file to CMakeLists.txt. Just confirm, can I ignore such breakage? It will be resolved by a "gn build: Merge ..." commit.

GN build bots shouldn't be sending failure notifications. If you get any from them, ignore them (so it's safe to recommit your patch), but probably worth posting on the mailing list saying that such a bot is sending them.

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

if (!O)
     return createFileError(
         Config.InputFilename,
         createStringError(object_error::parse_failed,
                           "unable to deserialize MachO object"));
 
   if (Error E = handleArgs(Config, *O))
     return createFileError(Config.InputFilename, std::move(E));
 
-  MachOWriter Writer(*O, In.is64Bit(), In.isLittleEndian(), Out);
+  // TODO: Support 16KB pages which employed in iOS arm64 binaries:
+  //       https://github.com/llvm/llvm-project/commit/1bebb2832ee312d3b0316dacff457a7a29435edb
+  const uint64_t PageSize = 4096;
+
+  MachOWriter Writer(*O, In.is64Bit(), In.isLittleEndian(), PageSize, Out);
   if (auto E = Writer.finalize())
     return E;
   return Writer.write();
 }
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

class MachOReader : public Reader {
   void readLoadCommands(Object &O) const;
   void readSymbolTable(Object &O) const;
   void readStringTable(Object &O) const;
   void readRebaseInfo(Object &O) const;
   void readBindInfo(Object &O) const;
   void readWeakBindInfo(Object &O) const;
   void readLazyBindInfo(Object &O) const;
   void readExportInfo(Object &O) const;
+  void readDataInCodeData(Object &O) const;
+  void readFunctionStartsData(Object &O) const;
+  void readIndirectSymbolTable(Object &O) const;
 
 public:
   explicit MachOReader(const object::MachOObjectFile &Obj) : MachOObj(Obj) {}
 
   std::unique_ptr<Object> create() const override;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

for (auto LoadCmd : MachOObj.load_commands()) {
     case MachO::LC_SEGMENT_64:
       LC.Sections =
           extractSections<MachO::section_64, MachO::segment_command_64>(
               LoadCmd, MachOObj, NextSectionIndex);
       break;
     case MachO::LC_SYMTAB:
       O.SymTabCommandIndex = O.LoadCommands.size();
       break;
+    case MachO::LC_DYSYMTAB:
+      O.DySymTabCommandIndex = O.LoadCommands.size();
+      break;
     case MachO::LC_DYLD_INFO:
     case MachO::LC_DYLD_INFO_ONLY:
       O.DyLdInfoCommandIndex = O.LoadCommands.size();
       break;
+    case MachO::LC_DATA_IN_CODE:
+      O.DataInCodeCommandIndex = O.LoadCommands.size();
+      break;
+    case MachO::LC_FUNCTION_STARTS:
+      O.FunctionStartsCommandIndex = O.LoadCommands.size();
+      break;
     }
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
     memcpy((void *)&(LC.MachOLoadCommand.LCStruct##_data), LoadCmd.Ptr,        \
            sizeof(MachO::LCStruct));                                           \
     if (MachOObj.isLittleEndian() != sys::IsLittleEndianHost)                  \
       MachO::swapStruct(LC.MachOLoadCommand.LCStruct##_data);                  \
     LC.Payload = ArrayRef<uint8_t>(                                            \

 void MachOReader::readLazyBindInfo(Object &O) const {
   O.LazyBinds.Opcodes = MachOObj.getDyldInfoLazyBindOpcodes();
 }
 
 void MachOReader::readExportInfo(Object &O) const {
   O.Exports.Trie = MachOObj.getDyldInfoExportsTrie();
 }
 
+void MachOReader::readDataInCodeData(Object &O) const {
+  if (!O.DataInCodeCommandIndex)
+    return;
+  const MachO::linkedit_data_command &LDC =
+      O.LoadCommands[*O.DataInCodeCommandIndex]
+          .MachOLoadCommand.linkedit_data_command_data;
+
+  O.DataInCode.Data = ArrayRef<uint8_t>(
+      reinterpret_cast<uint8_t *>(
+          const_cast<char *>(MachOObj.getData().data()) + LDC.dataoff),
+      LDC.datasize);
+}
+
+void MachOReader::readFunctionStartsData(Object &O) const {
+  if (!O.FunctionStartsCommandIndex)
+    return;
+  const MachO::linkedit_data_command &LDC =
+      O.LoadCommands[*O.FunctionStartsCommandIndex]
+          .MachOLoadCommand.linkedit_data_command_data;
+
+  O.FunctionStarts.Data = ArrayRef<uint8_t>(
+      reinterpret_cast<uint8_t *>(
+          const_cast<char *>(MachOObj.getData().data()) + LDC.dataoff),
+      LDC.datasize);
+}
+
+void MachOReader::readIndirectSymbolTable(Object &O) const {
+  MachO::dysymtab_command DySymTab = MachOObj.getDysymtabLoadCommand();
+  for (uint32_t i = 0; i < DySymTab.nindirectsyms; i++)
+    O.IndirectSymTable.Symbols.push_back(
+        MachOObj.getIndirectSymbolTableEntry(DySymTab, i));
+}
+
 std::unique_ptr<Object> MachOReader::create() const {
   auto Obj = llvm::make_unique<Object>();
   readHeader(*Obj);
   readLoadCommands(*Obj);
   readSymbolTable(*Obj);
   readStringTable(*Obj);
   readRebaseInfo(*Obj);
   readBindInfo(*Obj);
   readWeakBindInfo(*Obj);
   readLazyBindInfo(*Obj);
   readExportInfo(*Obj);
+  readDataInCodeData(*Obj);
+  readFunctionStartsData(*Obj);
+  readIndirectSymbolTable(*Obj);
   return Obj;
 }
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

 
 namespace objcopy {
 namespace macho {
 
 class MachOWriter {
   Object &O;
   bool Is64Bit;
   bool IsLittleEndian;
+  uint64_t PageSize;
   Buffer &B;
+  // Points to the __LINKEDIT segment if it exists.
+  MachO::macho_load_command *LinkEditLoadCommand = nullptr;
 
   size_t headerSize() const;
   size_t loadCommandsSize() const;
   size_t symTableSize() const;
   size_t strTableSize() const;
 
   void updateDySymTab(MachO::macho_load_command &MLC);
-  void updateSizeOfCmds();
+  uint32_t computeSizeOfCmds();
+  uint64_t layoutSegments();
+  uint64_t layoutRelocations(uint64_t Offset);
+  Error layoutTail(uint64_t Offset);
   Error layout();
 
   void writeHeader();
   void writeLoadCommands();
   template <typename StructType>
   void writeSectionInLoadCommand(const Section &Sec, uint8_t *&Out);
   void writeSections();
   void writeSymbolTable();
   void writeStringTable();
   void writeRebaseInfo();
   void writeBindInfo();
   void writeWeakBindInfo();
   void writeLazyBindInfo();
   void writeExportInfo();
+  void writeIndirectSymbolTable();
+  void writeDataInCodeData();
+  void writeFunctionStartsData();
   void writeTail();
 
 public:
-  MachOWriter(Object &O, bool Is64Bit, bool IsLittleEndian, Buffer &B)
-      : O(O), Is64Bit(Is64Bit), IsLittleEndian(IsLittleEndian), B(B) {}
+  MachOWriter(Object &O, bool Is64Bit, bool IsLittleEndian, uint64_t PageSize,
+              Buffer &B)
+      : O(O), Is64Bit(Is64Bit), IsLittleEndian(IsLittleEndian),
+        PageSize(PageSize), B(B) {}
 
   size_t totalSize() const;
   Error finalize();
   Error write();
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

if (O.DyLdInfoCommandIndex) {
     }
     if (DyLdInfoCommand.export_off) {
       assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
              "Incorrect trie size");
       Ends.push_back(DyLdInfoCommand.export_off + DyLdInfoCommand.export_size);
     }
   }
 
+  if (O.DySymTabCommandIndex) {
+    const MachO::dysymtab_command &DySymTabCommand =
+        O.LoadCommands[*O.DySymTabCommandIndex]
+            .MachOLoadCommand.dysymtab_command_data;
+
+    if (DySymTabCommand.indirectsymoff)
+      Ends.push_back(DySymTabCommand.indirectsymoff +
+                     sizeof(uint32_t) * O.IndirectSymTable.Symbols.size());
+  }
+
+  if (O.DataInCodeCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.DataInCodeCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Ends.push_back(LinkEditDataCommand.dataoff +
+                     LinkEditDataCommand.datasize);
+  }
+
+  if (O.FunctionStartsCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.FunctionStartsCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    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));
     }
const MachO::dyld_info_command &DyLdInfoCommand =
       O.LoadCommands[*O.DyLdInfoCommandIndex]
           .MachOLoadCommand.dyld_info_command_data;
   char *Out = (char *)B.getBufferStart() + DyLdInfoCommand.export_off;
   assert((DyLdInfoCommand.export_size == O.Exports.Trie.size()) &&
          "Incorrect export trie size");
   memcpy(Out, O.Exports.Trie.data(), O.Exports.Trie.size());
 }
 
+void MachOWriter::writeIndirectSymbolTable() {
+  if (!O.DySymTabCommandIndex)
+    return;
+
+  const MachO::dysymtab_command &DySymTabCommand =
+      O.LoadCommands[*O.DySymTabCommandIndex]
+          .MachOLoadCommand.dysymtab_command_data;
+
+  char *Out = (char *)B.getBufferStart() + DySymTabCommand.indirectsymoff;
+  assert((DySymTabCommand.nindirectsyms == O.IndirectSymTable.Symbols.size()) &&
+         "Incorrect indirect symbol table size");
+  memcpy(Out, O.IndirectSymTable.Symbols.data(),
+         sizeof(uint32_t) * O.IndirectSymTable.Symbols.size());
+}
+
+void MachOWriter::writeDataInCodeData() {
+  if (!O.DataInCodeCommandIndex)
+    return;
+  const MachO::linkedit_data_command &LinkEditDataCommand =
+      O.LoadCommands[*O.DataInCodeCommandIndex]
+          .MachOLoadCommand.linkedit_data_command_data;
+  char *Out = (char *)B.getBufferStart() + LinkEditDataCommand.dataoff;
+  assert((LinkEditDataCommand.datasize == O.DataInCode.Data.size()) &&
+         "Incorrect data in code data size");
+  memcpy(Out, O.DataInCode.Data.data(), O.DataInCode.Data.size());
+}
+
+void MachOWriter::writeFunctionStartsData() {
+  if (!O.FunctionStartsCommandIndex)
+    return;
+  const MachO::linkedit_data_command &LinkEditDataCommand =
+      O.LoadCommands[*O.FunctionStartsCommandIndex]
+          .MachOLoadCommand.linkedit_data_command_data;
+  char *Out = (char *)B.getBufferStart() + LinkEditDataCommand.dataoff;
+  assert((LinkEditDataCommand.datasize == O.FunctionStarts.Data.size()) &&
+         "Incorrect function starts data size");
+  memcpy(Out, O.FunctionStarts.Data.data(), O.FunctionStarts.Data.size());
+}
+
 void MachOWriter::writeTail() {
   typedef void (MachOWriter::*WriteHandlerType)(void);
   typedef std::pair<uint64_t, WriteHandlerType> WriteOperation;
   SmallVector<WriteOperation, 7> Queue;
 
   if (O.SymTabCommandIndex) {
     const MachO::symtab_command &SymTabCommand =
         O.LoadCommands[*O.SymTabCommandIndex]
if (O.DyLdInfoCommandIndex) {
     if (DyLdInfoCommand.lazy_bind_off)
       Queue.push_back(
           {DyLdInfoCommand.lazy_bind_off, &MachOWriter::writeLazyBindInfo});
     if (DyLdInfoCommand.export_off)
       Queue.push_back(
           {DyLdInfoCommand.export_off, &MachOWriter::writeExportInfo});
   }
 
+  if (O.DySymTabCommandIndex) {
+    const MachO::dysymtab_command &DySymTabCommand =
+        O.LoadCommands[*O.DySymTabCommandIndex]
+            .MachOLoadCommand.dysymtab_command_data;
+
+    if (DySymTabCommand.indirectsymoff)
+      Queue.push_back({DySymTabCommand.indirectsymoff,
+                       &MachOWriter::writeIndirectSymbolTable});
+  }
+
+  if (O.DataInCodeCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.DataInCodeCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Queue.push_back(
+          {LinkEditDataCommand.dataoff, &MachOWriter::writeDataInCodeData});
+  }
+
+  if (O.FunctionStartsCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.FunctionStartsCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Queue.push_back(
+          {LinkEditDataCommand.dataoff, &MachOWriter::writeFunctionStartsData});
+  }
+
   llvm::sort(Queue, [](const WriteOperation &LHS, const WriteOperation &RHS) {
     return LHS.first < RHS.first;
   });
 
   for (auto WriteOp : Queue)
     (this->*WriteOp.second)();
 }
 
-void MachOWriter::updateSizeOfCmds() {
-  auto Size = 0;
+uint32_t MachOWriter::computeSizeOfCmds() {
+  uint32_t Size = 0;
   for (const auto &LC : O.LoadCommands) {
     auto &MLC = LC.MachOLoadCommand;
     auto cmd = MLC.load_command_data.cmd;
-
     switch (cmd) {
     case MachO::LC_SEGMENT:
       Size += sizeof(MachO::segment_command) +
               sizeof(MachO::section) * LC.Sections.size();
       continue;
     case MachO::LC_SEGMENT_64:
       Size += sizeof(MachO::segment_command_64) +
               sizeof(MachO::section_64) * LC.Sections.size();
       continue;
     }
 
     switch (cmd) {
 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
   case MachO::LCName:                                                          \
-    Size += sizeof(MachO::LCStruct);                                           \
+    Size += sizeof(MachO::LCStruct) + LC.Payload.size();                       \
     break;
 #include "llvm/BinaryFormat/MachO.def"
 #undef HANDLE_LOAD_COMMAND
     }
   }
 
-  O.Header.SizeOfCmds = Size;
+  return Size;
 }
 
 // Updates the index and the number of local/external/undefined symbols. Here we
 // assume that MLC is a LC_DYSYMTAB and the nlist entries in the symbol table
 // are already sorted by the those types.
 void MachOWriter::updateDySymTab(MachO::macho_load_command &MLC) {
   uint32_t NumLocalSymbols = 0;
   auto Iter = O.SymTable.NameList.begin();
void MachOWriter::updateDySymTab(MachO::macho_load_command &MLC) {
   MLC.dysymtab_command_data.nextdefsym = NumExtDefSymbols;
   MLC.dysymtab_command_data.iundefsym = NumLocalSymbols + NumExtDefSymbols;
   MLC.dysymtab_command_data.nundefsym =
       O.SymTable.NameList.size() - (NumLocalSymbols + NumExtDefSymbols);
 }
 
 // Recomputes and updates offset and size fields in load commands and sections
 // since they could be modified.
-Error MachOWriter::layout() {
+uint64_t MachOWriter::layoutSegments() {
   auto SizeOfCmds = loadCommandsSize();
   auto Offset = headerSize() + SizeOfCmds;
   O.Header.NCmds = O.LoadCommands.size();
   O.Header.SizeOfCmds = SizeOfCmds;
 
   // Lay out sections.
   for (auto &LC : O.LoadCommands) {
     uint64_t FileOff = Offset;
+    auto &MLC = LC.MachOLoadCommand;
+    StringRef Segname;
+    switch (MLC.load_command_data.cmd) {
+    case MachO::LC_SEGMENT:
+      Segname = StringRef(MLC.segment_command_data.segname,
+                          strnlen(MLC.segment_command_data.segname,
+                                  sizeof(MLC.segment_command_data.segname)));
+      break;
+    case MachO::LC_SEGMENT_64:
+      Segname = StringRef(MLC.segment_command_64_data.segname,
+                          strnlen(MLC.segment_command_64_data.segname,
+                                  sizeof(MLC.segment_command_64_data.segname)));
+      break;
+    default:
+      continue;
+    }
+
+    if (Segname == "__LINKEDIT") {
+      // We update the __LINKEDIT segment later (in layoutTail).
+      assert(LC.Sections.empty() && "__LINKEDIT segment has sections");
+      LinkEditLoadCommand = &MLC;
+      continue;
+    }
+
+    // Update file offsets and sizes of sections.
     uint64_t VMSize = 0;
     uint64_t FileOffsetInSegment = 0;
     for (auto &Sec : LC.Sections) {
       if (!Sec.isVirtualSection()) {
         auto FilePaddingSize =
             OffsetToAlignment(FileOffsetInSegment, 1ull << Sec.Align);
         Sec.Offset = Offset + FileOffsetInSegment + FilePaddingSize;
         Sec.Size = Sec.Content.size();
         FileOffsetInSegment += FilePaddingSize + Sec.Size;
       }
 
       VMSize = std::max(VMSize, Sec.Addr + Sec.Size);
     }
 
     // TODO: Handle the __PAGEZERO segment.
-    auto &MLC = LC.MachOLoadCommand;
     switch (MLC.load_command_data.cmd) {
     case MachO::LC_SEGMENT:
       MLC.segment_command_data.cmdsize =
           sizeof(MachO::segment_command) +
           sizeof(MachO::section) * LC.Sections.size();
       MLC.segment_command_data.nsects = LC.Sections.size();
       MLC.segment_command_data.fileoff = FileOff;
       MLC.segment_command_data.vmsize = VMSize;
       MLC.segment_command_data.filesize = FileOffsetInSegment;
       break;
     case MachO::LC_SEGMENT_64:
       MLC.segment_command_64_data.cmdsize =
           sizeof(MachO::segment_command_64) +
           sizeof(MachO::section_64) * LC.Sections.size();
       MLC.segment_command_64_data.nsects = LC.Sections.size();
       MLC.segment_command_64_data.fileoff = FileOff;
       MLC.segment_command_64_data.vmsize = VMSize;
       MLC.segment_command_64_data.filesize = FileOffsetInSegment;
       break;
     }
 
     Offset += FileOffsetInSegment;
   }
 
-  // Lay out relocations.
+  return Offset;
+}
+
+uint64_t MachOWriter::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;
     }
 
-  // Lay out tail stuff.
-  auto NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
+  return Offset;
+}
+
+Error MachOWriter::layoutTail(uint64_t Offset) {
+  // The order of LINKEDIT elements is as follows:
+  // rebase info, binding info, weak binding info, lazy binding info, export
+  // trie, data-in-code, symbol table, indirect symbol table, symbol table
+  // strings.
+  uint64_t NListSize = Is64Bit ? sizeof(MachO::nlist_64) : sizeof(MachO::nlist);
+  uint64_t StartOfLinkEdit = Offset;
+  uint64_t StartOfRebaseInfo = StartOfLinkEdit;
+  uint64_t StartOfBindingInfo = StartOfRebaseInfo + O.Rebases.Opcodes.size();
+  uint64_t StartOfWeakBindingInfo = StartOfBindingInfo + O.Binds.Opcodes.size();
+  uint64_t StartOfLazyBindingInfo =
+      StartOfWeakBindingInfo + O.WeakBinds.Opcodes.size();
+  uint64_t StartOfExportTrie =
+      StartOfLazyBindingInfo + O.LazyBinds.Opcodes.size();
+  uint64_t StartOfFunctionStarts = StartOfExportTrie + O.Exports.Trie.size();
+  uint64_t StartOfDataInCode =
+      StartOfFunctionStarts + O.FunctionStarts.Data.size();
+  uint64_t StartOfSymbols = StartOfDataInCode + O.DataInCode.Data.size();
+  uint64_t StartOfIndirectSymbols =
+      StartOfSymbols + NListSize * O.SymTable.NameList.size();
+  uint64_t StartOfSymbolStrings =
+      StartOfIndirectSymbols +
+      sizeof(uint32_t) * O.IndirectSymTable.Symbols.size();
+  uint64_t LinkEditSize =
+      (StartOfSymbolStrings + strTableSize()) - StartOfLinkEdit;
+
+  // Now we have determined the layout of the contents of the __LINKEDIT
+  // segment. Update its load command.
+  if (LinkEditLoadCommand) {
+    MachO::macho_load_command *MLC = LinkEditLoadCommand;
+    switch (LinkEditLoadCommand->load_command_data.cmd) {
+    case MachO::LC_SEGMENT:
+      MLC->segment_command_data.cmdsize = sizeof(MachO::segment_command);
+      MLC->segment_command_data.fileoff = StartOfLinkEdit;
+      MLC->segment_command_data.vmsize = alignTo(LinkEditSize, PageSize);
+      MLC->segment_command_data.filesize = LinkEditSize;
+      break;
+    case MachO::LC_SEGMENT_64:
+      MLC->segment_command_64_data.cmdsize = sizeof(MachO::segment_command_64);
+      MLC->segment_command_64_data.fileoff = StartOfLinkEdit;
+      MLC->segment_command_64_data.vmsize = alignTo(LinkEditSize, PageSize);
+      MLC->segment_command_64_data.filesize = LinkEditSize;
+      break;
+    }
+  }
+
   for (auto &LC : O.LoadCommands) {
     auto &MLC = LC.MachOLoadCommand;
     auto cmd = MLC.load_command_data.cmd;
     switch (cmd) {
     case MachO::LC_SYMTAB:
-      MLC.symtab_command_data.symoff = Offset;
+      MLC.symtab_command_data.symoff = StartOfSymbols;
       MLC.symtab_command_data.nsyms = O.SymTable.NameList.size();
-      Offset += NListSize * MLC.symtab_command_data.nsyms;
-      MLC.symtab_command_data.stroff = Offset;
-      Offset += MLC.symtab_command_data.strsize;
+      MLC.symtab_command_data.stroff = StartOfSymbolStrings;
+      MLC.symtab_command_data.strsize = strTableSize();
       break;
     case MachO::LC_DYSYMTAB: {
       if (MLC.dysymtab_command_data.ntoc != 0 ||
           MLC.dysymtab_command_data.nmodtab != 0 ||
           MLC.dysymtab_command_data.nextrefsyms != 0 ||
           MLC.dysymtab_command_data.nlocrel != 0 ||
           MLC.dysymtab_command_data.nextrel != 0)
         return createStringError(llvm::errc::not_supported,
                                  "shared library is not yet supported");
 
-      if (MLC.dysymtab_command_data.nindirectsyms != 0)
-        return createStringError(llvm::errc::not_supported,
-                                 "indirect symbol table is not yet supported");
+      if (!O.IndirectSymTable.Symbols.empty()) {
+        MLC.dysymtab_command_data.indirectsymoff = StartOfIndirectSymbols;
+        MLC.dysymtab_command_data.nindirectsyms =
+            O.IndirectSymTable.Symbols.size();
+      }
 
       updateDySymTab(MLC);
       break;
     }
+    case MachO::LC_DATA_IN_CODE:
+      MLC.linkedit_data_command_data.dataoff = StartOfDataInCode;
+      MLC.linkedit_data_command_data.datasize = O.DataInCode.Data.size();
+      break;
+    case MachO::LC_FUNCTION_STARTS:
+      MLC.linkedit_data_command_data.dataoff = StartOfFunctionStarts;
+      MLC.linkedit_data_command_data.datasize = O.FunctionStarts.Data.size();
+      break;
+    case MachO::LC_DYLD_INFO:
+    case MachO::LC_DYLD_INFO_ONLY:
+      MLC.dyld_info_command_data.rebase_off =
+          O.Rebases.Opcodes.empty() ? 0 : StartOfRebaseInfo;
+      MLC.dyld_info_command_data.rebase_size = O.Rebases.Opcodes.size();
+      MLC.dyld_info_command_data.bind_off =
+          O.Binds.Opcodes.empty() ? 0 : StartOfBindingInfo;
+      MLC.dyld_info_command_data.bind_size = O.Binds.Opcodes.size();
+      MLC.dyld_info_command_data.weak_bind_off =
+          O.WeakBinds.Opcodes.empty() ? 0 : StartOfWeakBindingInfo;
+      MLC.dyld_info_command_data.weak_bind_size = O.WeakBinds.Opcodes.size();
+      MLC.dyld_info_command_data.lazy_bind_off =
+          O.LazyBinds.Opcodes.empty() ? 0 : StartOfLazyBindingInfo;
+      MLC.dyld_info_command_data.lazy_bind_size = O.LazyBinds.Opcodes.size();
+      MLC.dyld_info_command_data.export_off =
+          O.Exports.Trie.empty() ? 0 : StartOfExportTrie;
+      MLC.dyld_info_command_data.export_size = O.Exports.Trie.size();
+      break;
+    case MachO::LC_LOAD_DYLINKER:
+    case MachO::LC_MAIN:
+    case MachO::LC_RPATH:
     case MachO::LC_SEGMENT:
     case MachO::LC_SEGMENT_64:
     case MachO::LC_VERSION_MIN_MACOSX:
     case MachO::LC_BUILD_VERSION:
     case MachO::LC_ID_DYLIB:
     case MachO::LC_LOAD_DYLIB:
     case MachO::LC_UUID:
     case MachO::LC_SOURCE_VERSION:
       // Nothing to update.
       break;
     default:
       // Abort if it's unsupported in order to prevent corrupting the object.
       return createStringError(llvm::errc::not_supported,
                                "unsupported load command (cmd=0x%x)", cmd);
     }
   }
 
   return Error::success();
 }
 
+// Recomputes and updates offset and size fields in load commands and sections
+// since they could be modified.
+Error MachOWriter::layout() {
+  uint64_t Offset = layoutSegments();
+  Offset = layoutRelocations(Offset);
+  return layoutTail(Offset);
+}
+
 Error MachOWriter::finalize() {
-  updateSizeOfCmds();
+  O.Header.NCmds = O.LoadCommands.size();
+  O.Header.SizeOfCmds = computeSizeOfCmds();
 
   if (auto E = layout())
     return E;
 
   return Error::success();
 }
 
 Error MachOWriter::write() {

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

 };
 
 /// The location of the symbol table inside the binary is described by LC_SYMTAB
 /// load command.
 struct SymbolTable {
   std::vector<NListEntry> NameList;
 };
 
+struct IndirectSymbolTable {
+  std::vector<uint32_t> Symbols;
+};
+
 /// The location of the string table inside the binary is described by LC_SYMTAB
 /// load command.
 struct StringTable {
   std::vector<std::string> Strings;
 };
 
 /// 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

 /// followed by each edge.
 /// Each edge is a zero terminated UTF8 of the addition chars
 /// in the symbol, followed by a uleb128 offset for the node that
 /// edge points to.
 struct ExportInfo {
   ArrayRef<uint8_t> Trie;
 };
 
+struct LinkData {
+  ArrayRef<uint8_t> Data;
+};
+
 struct Object {
   MachHeader Header;
   std::vector<LoadCommand> LoadCommands;
 
   SymbolTable SymTable;
   StringTable StrTable;
 
   RebaseInfo Rebases;
   BindInfo Binds;
   WeakBindInfo WeakBinds;
   LazyBindInfo LazyBinds;
   ExportInfo Exports;
+  IndirectSymbolTable IndirectSymTable;
+  LinkData DataInCode;
+  LinkData FunctionStarts;
 
   /// The index of LC_SYMTAB load command if present.
   Optional<size_t> SymTabCommandIndex;
   /// The index of LC_DYLD_INFO or LC_DYLD_INFO_ONLY load command if present.
   Optional<size_t> DyLdInfoCommandIndex;
+  /// The index LC_DYSYMTAB load comamnd if present.
+  Optional<size_t> DySymTabCommandIndex;
+  /// The index LC_DATA_IN_CODE load comamnd if present.
+  Optional<size_t> DataInCodeCommandIndex;
+  /// The index LC_FUNCTION_STARTS load comamnd if present.
+  Optional<size_t> FunctionStartsCommandIndex;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm
 
 #endif // LLVM_OBJCOPY_MACHO_OBJECT_H