[llvm-objcopy][MachO] Add llvm-strip support for newer load commands

[keith]

Summary

Previously llvm-strip would fail because of unknown commands.

Fixes https://bugs.llvm.org/show_bug.cgi?id=50044

[keith]

I'm not sure how this should be tested since there aren't cases where we actually link binaries before being able to run this

[jhenderson]

In D113734#3126419, @keith wrote:

I'm not sure how this should be tested since there aren't cases where we actually link binaries before being able to run this

I'm not too familiar with the Mach-O side of llvm-objcopy, but a quick search shows that at least some (possibly all) of the existing load commands are tested using yaml2obj-generated inputs. Take a look at the eixsting tests like lc-load-weak-dylib.test. If yaml2obj support needs to be extended for the new load commands, it should be fairly simple to do so.

[aprantl]

In D113734#3126419, @keith wrote:

I'm not sure how this should be tested since there aren't cases where we actually link binaries before being able to run this

Just last week I added a new option to obj2yaml to dump the entire raw LINKEDIT/DATA segment of a binary. Maybe this is helpful here.

[keith]

In D113734#3126543, @jhenderson wrote:

In D113734#3126419, @keith wrote:

I'm not sure how this should be tested since there aren't cases where we actually link binaries before being able to run this

I'm not too familiar with the Mach-O side of llvm-objcopy, but a quick search shows that at least some (possibly all) of the existing load commands are tested using yaml2obj-generated inputs. Take a look at the eixsting tests like lc-load-weak-dylib.test. If yaml2obj support needs to be extended for the new load commands, it should be fairly simple to do so.

Yea this make sense, my problem is that the failure case I hit while testing this was that the strip would succeed, but the binary would be malformed because of these offsets being incorrectly calculated, and fail to execute. So I need to come up with some thorough before and after for that I guess

[keith]

In D113734#3128319, @aprantl wrote:

In D113734#3126419, @keith wrote:

I'm not sure how this should be tested since there aren't cases where we actually link binaries before being able to run this

Just last week I added a new option to obj2yaml to dump the entire raw LINKEDIT/DATA segment of a binary. Maybe this is helpful here.

I'm not sure what the backwards compat should be with previous versions of nm (or maybe just apple's cctools version in general), but it looks like there are some issues with this today:

% echo "int main() { return 0; }" > /tmp/bar.c
% clang /tmp/bar.c -o /tmp/main
% nm /tmp/main
0000000100000000 T __mh_execute_header
0000000100003fa4 T _main
% ./bin/obj2yaml /tmp/main | ./bin/yaml2obj > /tmp/new
% nm /tmp/new
LLVM ERROR: bad chained fixups: unknown imports format: 0
zsh: abort      nm /tmp/new

[keith]

Add test case

[keith]

@alexander-shaposhnikov mind checking this one out? related to the other load command update

[BertalanD]

@keith is there a reason Object::ExportsTrie was added instead of reusing the Exports member? I read in D107673 that LC_DYLD_EXPORTS_TRIE and LD_DYLD_INFO are mutually exclusive, so we could re-use the same trie for both load commands.

[keith]

In D113734#3641737, @BertalanD wrote:

@keith is there a reason Object::ExportsTrie was added instead of reusing the Exports member? I read in D107673 that LC_DYLD_EXPORTS_TRIE and LD_DYLD_INFO are mutually exclusive, so we could re-use the same trie for both load commands.

Interesting! I didn't consider this option when I was writing this IIRC, I was just mirroring the 1:1 command to member. So if that works that sounds fine to me!

llvm/test/tools/llvm-objcopy/MachO/Inputs/strip-chained-fixups.yaml

+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x100000C
+  cpusubtype:      0x0
+  filetype:        0x2
+  ncmds:           16
+  sizeofcmds:      744
+  flags:           0x200085
+  reserved:        0x0
+LoadCommands:
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __PAGEZERO
+    vmaddr:          0
+    vmsize:          4294967296
+    fileoff:         0
+    filesize:        0
+    maxprot:         0
+    initprot:        0
+    nsects:          0
+    flags:           0
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         __TEXT
+    vmaddr:          4294967296
+    vmsize:          16384
+    fileoff:         0
+    filesize:        16384
+    maxprot:         5
+    initprot:        5
+    nsects:          2
+    flags:           0
+    Sections:
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x100003F98
+        size:            24
+        offset:          0x3F98
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         C0035FD6FF4300D100008052FF0F00B9FF430091C0035FD6
+      - sectname:        __unwind_info
+        segname:         __TEXT
+        addr:            0x100003FB0
+        size:            80
+        offset:          0x3FB0
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x0
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         010000001C000000000000001C000000000000001C00000002000000983F00003400000034000000B13F00000000000034000000030000000C0002001400020000000001040000000010000200000002
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __LINKEDIT
+    vmaddr:          4294983680
+    vmsize:          16384
+    fileoff:         16384
+    filesize:        753
+    maxprot:         1
+    initprot:        1
+    nsects:          0
+    flags:           0
+  - cmd:             LC_DYLD_CHAINED_FIXUPS
+    cmdsize:         16
+    dataoff:         16384
+    datasize:        56
+  - cmd:             LC_DYLD_EXPORTS_TRIE
+    cmdsize:         16
+    dataoff:         16440
+    datasize:        56
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          16504
+    nsyms:           15
+    stroff:          16744
+    strsize:         120
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       12
+    iextdefsym:      12
+    nextdefsym:      3
+    iundefsym:       15
+    nundefsym:       0
+    tocoff:          0
+    ntoc:            0
+    modtaboff:       0
+    nmodtab:         0
+    extrefsymoff:    0
+    nextrefsyms:     0
+    indirectsymoff:  0
+    nindirectsyms:   0
+    extreloff:       0
+    nextrel:         0
+    locreloff:       0
+    nlocrel:         0
+  - cmd:             LC_LOAD_DYLINKER
+    cmdsize:         32
+    name:            12
+    Content:         '/usr/lib/dyld'
+    ZeroPadBytes:    7
+  - cmd:             LC_UUID
+    cmdsize:         24
+    uuid:            F445529E-643C-3A38-8F59-AB64566BCAFF
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         32
+    platform:        1
+    minos:           786432
+    sdk:             786432
+    ntools:          1
+    Tools:
+      - tool:            3
+        version:         46596096
+  - cmd:             LC_SOURCE_VERSION
+    cmdsize:         16
+    version:         0
+  - cmd:             LC_MAIN
+    cmdsize:         24
+    entryoff:        16284
+    stacksize:       0
+  - cmd:             LC_LOAD_DYLIB
+    cmdsize:         56
+    dylib:
+      name:            24
+      timestamp:       2
+      current_version: 85917696
+      compatibility_version: 65536
+    Content:         '/usr/lib/libSystem.B.dylib'
+    ZeroPadBytes:    6
+  - cmd:             LC_FUNCTION_STARTS
+    cmdsize:         16
+    dataoff:         16496
+    datasize:        8
+  - cmd:             LC_DATA_IN_CODE
+    cmdsize:         16
+    dataoff:         16504
+    datasize:        0
+  - cmd:             LC_CODE_SIGNATURE
+    cmdsize:         16
+    dataoff:         16864
+    datasize:        273
+LinkEditData:
+  NameList:
+    - n_strx:          33
+      n_type:          0x64
+      n_sect:          0
+      n_desc:          0
+      n_value:         0
+    - n_strx:          39
+      n_type:          0x64
+      n_sect:          0
+      n_desc:          0
+      n_value:         0
+    - n_strx:          46
+      n_type:          0x66
+      n_sect:          0
+      n_desc:          1
+      n_value:         1636754403
+    - n_strx:          1
+      n_type:          0x2E
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983576
+    - n_strx:          109
+      n_type:          0x24
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983576
+    - n_strx:          1
+      n_type:          0x24
+      n_sect:          0
+      n_desc:          0
+      n_value:         4
+    - n_strx:          1
+      n_type:          0x4E
+      n_sect:          1
+      n_desc:          0
+      n_value:         4
+    - n_strx:          1
+      n_type:          0x2E
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983580
+    - n_strx:          114
+      n_type:          0x24
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983580
+    - n_strx:          1
+      n_type:          0x24
+      n_sect:          0
+      n_desc:          0
+      n_value:         20
+    - n_strx:          1
+      n_type:          0x4E
+      n_sect:          1
+      n_desc:          0
+      n_value:         20
+    - n_strx:          1
+      n_type:          0x64
+      n_sect:          1
+      n_desc:          0
+      n_value:         0
+    - n_strx:          2
+      n_type:          0xF
+      n_sect:          1
+      n_desc:          16
+      n_value:         4294967296
+    - n_strx:          22
+      n_type:          0xF
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983576
+    - n_strx:          27
+      n_type:          0xF
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294983580
+  StringTable:
+    - ' '
+    - __mh_execute_header
+    - _foo
+    - _main
+    - '/tmp/'
+    - main.c
+    - '/var/folders/gj/wf3swl0x215b2sq1qy84kzkm0000gn/T/main-e32fe7.o'
+    - _foo
+    - _main
+...

llvm/test/tools/llvm-objcopy/MachO/strip-all.test

 ## Show that llvm-objcopy/llvm-strip removes all symbols and debug sections.
 
 # RUN: yaml2obj %p/Inputs/strip-all.yaml -o %t.exec
 # RUN: yaml2obj %p/Inputs/strip-all-with-dwarf.yaml -o %t.dwarf
+# RUN: yaml2obj %p/Inputs/strip-chained-fixups.yaml -o %t.fixups
 
 ## Check that the symbol list satisfies the order: local / defined external /
 ## undefined external, otherwise llvm-objcopy will fail.
 # RUN: llvm-objcopy %t.exec /dev/null
 
 # RUN: llvm-objcopy --strip-all %t.exec %t.exec.stripped
 # RUN: llvm-readobj --sections --relocations --symbols %t.exec.stripped \
 # RUN:   | FileCheck --check-prefix=COMMON %s
 
 # RUN: llvm-objcopy --strip-all %t.dwarf %t.dwarf.stripped
 # RUN: llvm-readobj --sections --relocations --symbols %t.dwarf.stripped \
 # RUN:   | FileCheck --check-prefixes=COMMON,DWARF %s
 
+# RUN: llvm-objcopy --strip-all %t.fixups %t.fixups.stripped
+# RUN: llvm-readobj --sections --relocations --symbols %t.fixups.stripped \
+# RUN:   | FileCheck --check-prefix=COMMON %s
+
 ## The output of "llvm-strip" should be identical with that of
 ## "llvm-strip --strip-all" and "llvm-objcopy --strip-all".
 # RUN: llvm-strip %t.exec -o %t2
 # RUN: llvm-strip --strip-all %t.exec -o %t3
 # cmp %t2 %t.exec.stripped
 # cmp %t3 %t.exec.stripped
 
 # RUN: llvm-strip %t.dwarf -o %t4
 # RUN: llvm-strip --strip-all %t.dwarf -o %t5
 # cmp %t4 %t.dwarf.stripped
 # cmp %t5 %t.dwarf.stripped
 
 # RUN: llvm-lipo %t.dwarf -create -output %t.dwarf.universal
 # RUN: llvm-strip %t.dwarf.universal -o %t.dwarf.universal.stripped
 # RUN: llvm-lipo %t.dwarf.universal.stripped -thin x86_64 -output %t6
 # RUN: cmp %t6 %t.dwarf.stripped
 
+# RUN: llvm-strip %t.exec -o %t7
+# RUN: llvm-strip --strip-all %t.exec -o %t8
+# cmp %t7 %t.fixups.stripped
+# cmp %t8 %t.fixups.stripped
+
 ## Make sure that debug sections are removed.
 # DWARF:       Sections [
 # DWARF-NOT:     Name: __debug_str
 # DWARF-NOT:     Name: __debug_abbrev
 # DWARF-NOT:     Name: __debug_info
 # DWARF-NOT:     Name: __debug_macinfo
 # DWARF-NOT:     Name: __apple_names
 # DWARF-NOT:     Name: __apple_objc

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

Error MachOLayoutBuilder::layoutTail(uint64_t 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 =
+  uint64_t StartOfDyldExportsTrie =
       StartOfFunctionStarts + O.FunctionStarts.Data.size();
+  uint64_t StartOfChainedFixups =
+      StartOfDyldExportsTrie + O.ExportsTrie.Data.size();
+  uint64_t StartOfDataInCode =
+      StartOfChainedFixups + O.ChainedFixups.Data.size();
   uint64_t StartOfLinkerOptimizationHint =
       StartOfDataInCode + O.DataInCode.Data.size();
   uint64_t StartOfSymbols =
       StartOfLinkerOptimizationHint + O.LinkerOptimizationHint.Data.size();
   uint64_t StartOfIndirectSymbols =
       StartOfSymbols + NListSize * O.SymTable.Symbols.size();
   uint64_t StartOfSymbolStrings =
       StartOfIndirectSymbols +
case MachO::LC_LINKER_OPTIMIZATION_HINT:
       MLC.linkedit_data_command_data.dataoff = StartOfLinkerOptimizationHint;
       MLC.linkedit_data_command_data.datasize =
           O.LinkerOptimizationHint.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_CHAINED_FIXUPS:
+      MLC.linkedit_data_command_data.dataoff = StartOfChainedFixups;
+      MLC.linkedit_data_command_data.datasize = O.ChainedFixups.Data.size();
+      break;
+    case MachO::LC_DYLD_EXPORTS_TRIE:
+      MLC.linkedit_data_command_data.dataoff = StartOfDyldExportsTrie;
+      MLC.linkedit_data_command_data.datasize = O.ExportsTrie.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();

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

class MachOReader : public Reader {
   void readWeakBindInfo(Object &O) const;
   void readLazyBindInfo(Object &O) const;
   void readExportInfo(Object &O) const;
   void readLinkData(Object &O, Optional<size_t> LCIndex, LinkData &LD) const;
   void readCodeSignature(Object &O) const;
   void readDataInCodeData(Object &O) const;
   void readLinkerOptimizationHint(Object &O) const;
   void readFunctionStartsData(Object &O) const;
+  void readExportsTrie(Object &O) const;
+  void readChainedFixups(Object &O) const;
   void readIndirectSymbolTable(Object &O) const;
   void readSwiftVersion(Object &O) const;
 
 public:
   explicit MachOReader(const object::MachOObjectFile &Obj) : MachOObj(Obj) {}
 
   Expected<std::unique_ptr<Object>> create() const override;
 };
 
 } // end namespace macho
 } // end namespace objcopy
 } // end namespace llvm

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

case MachO::LC_DATA_IN_CODE:
       O.DataInCodeCommandIndex = O.LoadCommands.size();
       break;
     case MachO::LC_LINKER_OPTIMIZATION_HINT:
       O.LinkerOptimizationHintCommandIndex = O.LoadCommands.size();
       break;
     case MachO::LC_FUNCTION_STARTS:
       O.FunctionStartsCommandIndex = O.LoadCommands.size();
       break;
+    case MachO::LC_DYLD_EXPORTS_TRIE:
+      O.ExportsTrieCommandIndex = O.LoadCommands.size();
+      break;
+    case MachO::LC_DYLD_CHAINED_FIXUPS:
+      O.ChainedFixupsCommandIndex = 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);                  \
     if (LoadCmd.C.cmdsize > sizeof(MachO::LCStruct))                           \
void MachOReader::readLinkerOptimizationHint(Object &O) const {
   return readLinkData(O, O.LinkerOptimizationHintCommandIndex,
                       O.LinkerOptimizationHint);
 }
 
 void MachOReader::readFunctionStartsData(Object &O) const {
   return readLinkData(O, O.FunctionStartsCommandIndex, O.FunctionStarts);
 }
 
+void MachOReader::readExportsTrie(Object &O) const {
+  return readLinkData(O, O.ExportsTrieCommandIndex, O.ExportsTrie);
+}
+
+void MachOReader::readChainedFixups(Object &O) const {
+  return readLinkData(O, O.ChainedFixupsCommandIndex, O.ChainedFixups);
+}
+
 void MachOReader::readIndirectSymbolTable(Object &O) const {
   MachO::dysymtab_command DySymTab = MachOObj.getDysymtabLoadCommand();
   constexpr uint32_t AbsOrLocalMask =
       MachO::INDIRECT_SYMBOL_LOCAL | MachO::INDIRECT_SYMBOL_ABS;
   for (uint32_t i = 0; i < DySymTab.nindirectsyms; ++i) {
     uint32_t Index = MachOObj.getIndirectSymbolTableEntry(DySymTab, i);
     if ((Index & AbsOrLocalMask) != 0)
       O.IndirectSymTable.Symbols.emplace_back(Index, None);
Expected<std::unique_ptr<Object>> MachOReader::create() const {
   readRebaseInfo(*Obj);
   readBindInfo(*Obj);
   readWeakBindInfo(*Obj);
   readLazyBindInfo(*Obj);
   readExportInfo(*Obj);
   readDataInCodeData(*Obj);
   readLinkerOptimizationHint(*Obj);
   readFunctionStartsData(*Obj);
+  readExportsTrie(*Obj);
+  readChainedFixups(*Obj);
   readIndirectSymbolTable(*Obj);
   readSwiftVersion(*Obj);
   return std::move(Obj);
 }

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

class MachOWriter {
   void writeLazyBindInfo();
   void writeExportInfo();
   void writeIndirectSymbolTable();
   void writeLinkData(Optional<size_t> LCIndex, const LinkData &LD);
   void writeCodeSignatureData();
   void writeDataInCodeData();
   void writeLinkerOptimizationHint();
   void writeFunctionStartsData();
+  void writeChainedFixupsData();
+  void writeExportsTrieData();
   void writeTail();
 
 public:
   MachOWriter(Object &O, bool Is64Bit, bool IsLittleEndian,
               StringRef OutputFileName, uint64_t PageSize, raw_ostream &Out)
       : O(O), Is64Bit(Is64Bit), IsLittleEndian(IsLittleEndian),
         PageSize(PageSize), Out(Out),
         LayoutBuilder(O, Is64Bit, OutputFileName, PageSize) {}

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

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);
   }
 
+  if (O.ChainedFixupsCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.ChainedFixupsCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Ends.push_back(LinkEditDataCommand.dataoff +
+                     LinkEditDataCommand.datasize);
+  }
+
+  if (O.ExportsTrieCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.ExportsTrieCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Ends.push_back(LinkEditDataCommand.dataoff +
+                     LinkEditDataCommand.datasize);
+  }
+
   // Otherwise, use the last section / reloction.
   for (const LoadCommand &LC : O.LoadCommands)
     for (const std::unique_ptr<Section> &S : LC.Sections) {
       if (!S->hasValidOffset()) {
         assert((S->Offset == 0) && "Skipped section's offset must be zero");
         assert((S->isVirtualSection() || S->Size == 0) &&
                "Non-zero-fill sections with zero offset must have zero size");
         continue;
void MachOWriter::writeLinkerOptimizationHint() {
   return writeLinkData(O.LinkerOptimizationHintCommandIndex,
                        O.LinkerOptimizationHint);
 }
 
 void MachOWriter::writeFunctionStartsData() {
   return writeLinkData(O.FunctionStartsCommandIndex, O.FunctionStarts);
 }
 
+void MachOWriter::writeChainedFixupsData() {
+  return writeLinkData(O.ChainedFixupsCommandIndex, O.ChainedFixups);
+}
+
+void MachOWriter::writeExportsTrieData() {
+  return writeLinkData(O.ExportsTrieCommandIndex, O.ExportsTrie);
+}
+
 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]
const MachO::linkedit_data_command &LinkEditDataCommand =
         O.LoadCommands[*O.FunctionStartsCommandIndex]
             .MachOLoadCommand.linkedit_data_command_data;
 
     if (LinkEditDataCommand.dataoff)
       Queue.emplace_back(LinkEditDataCommand.dataoff,
                          &MachOWriter::writeFunctionStartsData);
   }
 
+  if (O.ChainedFixupsCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.ChainedFixupsCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Queue.emplace_back(LinkEditDataCommand.dataoff,
+                         &MachOWriter::writeChainedFixupsData);
+  }
+
+  if (O.ExportsTrieCommandIndex) {
+    const MachO::linkedit_data_command &LinkEditDataCommand =
+        O.LoadCommands[*O.ExportsTrieCommandIndex]
+            .MachOLoadCommand.linkedit_data_command_data;
+
+    if (LinkEditDataCommand.dataoff)
+      Queue.emplace_back(LinkEditDataCommand.dataoff,
+                         &MachOWriter::writeExportsTrieData);
+  }
+
   llvm::sort(Queue, [](const WriteOperation &LHS, const WriteOperation &RHS) {
     return LHS.first < RHS.first;
   });
 
   for (auto WriteOp : Queue)
     (this->*WriteOp.second)();
 }
 

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

struct Object {
   BindInfo Binds;
   WeakBindInfo WeakBinds;
   LazyBindInfo LazyBinds;
   ExportInfo Exports;
   IndirectSymbolTable IndirectSymTable;
   LinkData DataInCode;
   LinkData LinkerOptimizationHint;
   LinkData FunctionStarts;
+  LinkData ExportsTrie;
+  LinkData ChainedFixups;
 
   Optional<uint32_t> SwiftVersion;
 
   /// The index of LC_CODE_SIGNATURE load command if present.
   Optional<size_t> CodeSignatureCommandIndex;
   /// 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 of LC_LINKER_OPTIMIZATIN_HINT load comamnd if present.
   Optional<size_t> LinkerOptimizationHintCommandIndex;
   /// The index LC_FUNCTION_STARTS load comamnd if present.
   Optional<size_t> FunctionStartsCommandIndex;
+  /// The index LC_DYLD_CHAINED_FIXUPS load comamnd if present.
+  Optional<size_t> ChainedFixupsCommandIndex;
+  /// The index LC_DYLD_EXPORTS_TRIE load comamnd if present.
+  Optional<size_t> ExportsTrieCommandIndex;
   /// The index of the LC_SEGMENT or LC_SEGMENT_64 load command
   /// corresponding to the __TEXT segment.
   Optional<size_t> TextSegmentCommandIndex;
 
   BumpPtrAllocator Alloc;
   StringSaver NewSectionsContents;
 
   Object() : NewSectionsContents(Alloc) {}

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

case MachO::LC_DATA_IN_CODE:
       DataInCodeCommandIndex = Index;
       break;
     case MachO::LC_LINKER_OPTIMIZATION_HINT:
       LinkerOptimizationHintCommandIndex = Index;
       break;
     case MachO::LC_FUNCTION_STARTS:
       FunctionStartsCommandIndex = Index;
       break;
+    case MachO::LC_DYLD_CHAINED_FIXUPS:
+      ChainedFixupsCommandIndex = Index;
+      break;
+    case MachO::LC_DYLD_EXPORTS_TRIE:
+      ExportsTrieCommandIndex = Index;
+      break;
     }
   }
 }
 
 Error Object::removeLoadCommands(
     function_ref<bool(const LoadCommand &)> ToRemove) {
   auto It = std::stable_partition(
       LoadCommands.begin(), LoadCommands.end(),