[ObjectYAML][MachO] Add basic chained fixups support

[keith]

Summary

This adds the most basic versions of chained fixups / dyld exports trie
support by encoding and decoding the bytes directly instead of with a
structured approach. This is at least useful to be able to write tests
from other tools without having to check in binaries, but in the future
we might want to replace this format with one mirroring the actual
format.

[jhenderson]

I don't really know Mach-O myself, so I can't really comment on the correctness of this patch.

llvm/lib/Object/MachOObjectFile.cpp

1384–1387

I see this pattern is very common. I think it would be worth factoring out the repetivtive function call into a lambda, to save repeating most of the arguments (*this, Load, I, and Elements appear to be common to all checkLinkeditDataCommand). This might be worth doing as a prerequisite patch, and tidying up the checkDyldInfoCommand calls in the same manner. There might be other refactorings worth doing to reduce repetitiveness even further, but that's probably going a bit far.

llvm/test/ObjectYAML/MachO/chained_fixups.yaml

184–185

These look incomplete to me?

[keith]

Include all data in test

llvm/lib/Object/MachOObjectFile.cpp

1384–1387

Yea I can think about that as a follow up, it's a bit of a pain with how these string + constant representations are duplicated

llvm/test/ObjectYAML/MachO/chained_fixups.yaml

184–185

Yea I was intentionally adding just enough to make sure something came through here, but I can verify 1:1 to be safe

[jhenderson]

Okay, I'm happy with the comments I made, but as mentioned, someone else will need to look at this patch from a Mach-O perspective.

llvm/test/ObjectYAML/MachO/chained_fixups.yaml

184

CHECK-NEXT here and below.

[keith]

Use CHECK-NEXT for order of bytes

[MaskRay]

LGTM

llvm/lib/ObjectYAML/MachOEmitter.cpp

522

emplace_back

527

emplace_back

[BertalanD]

What's the status on this? The changes look good to me, and have already been approved by @MaskRay.

I would like to use this for a test in D129430.

[keith]

I paused here as on another diff @aprantl mentioned they were working on a more sophisticated version of this. @aprantl any update on your side?

[thakis]

Given we're kind of blocked on this, let's land this and then replace it with the better version once it's done. (That shouldn't cause aprantl more work, since reverting this before landing their change is easy.)

[thakis]

llvm/lib/Object/MachOObjectFile.cpp

1387

Hm, is this diff very old? phab says "Feb 2022", but…oh I see, https://reviews.llvm.org/D113630 is aprantl's change that landed concurrently with this (?)

[thakis]

I think we can do something like in llvm/test/Object/Inputs/MachO/chained-fixups.yaml for our thing, so we're (probably) not blocked on this after all.

But it looks to me like aprantl's thing is maybe landed and this just needs rebasing.

[keith]

rebase

[keith]

In D119671#3647961, @thakis wrote:

I think we can do something like in llvm/test/Object/Inputs/MachO/chained-fixups.yaml for our thing, so we're (probably) not blocked on this after all.

But it looks to me like aprantl's thing is maybe landed and this just needs rebasing.

Given the workaround of just including the raw section info, I wonder now if this is worth doing unless we actually support more sophisticated structure, what do you think?

[aprantl]

Adding @Alpha as a reviewer, who expressed interest in continuing my effort to upstream the Apple implementation.

[thakis]

In D119671#3680236, @aprantl wrote:

Adding @Alpha as a reviewer, who expressed interest in continuing my effort to upstream the Apple implementation.

We're interested in adding support for chained fixups to ld64.lld soon. So it'd be nice if you could upstream things soon; else we'll have to reimplement them until the upstreaming changes arrive.

[keith]

Dropping this for the upstream apple stuff hopefully coming in the future. We can reopen if needed. For now you can just save linkedit data directly.

llvm/include/llvm/Object/MachO.h

public:
   MachO::dysymtab_command getDysymtabLoadCommand() const;
   MachO::linkedit_data_command getDataInCodeLoadCommand() const;
   MachO::linkedit_data_command getLinkOptHintsLoadCommand() const;
   ArrayRef<uint8_t> getDyldInfoRebaseOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoWeakBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoLazyBindOpcodes() const;
   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
+  ArrayRef<uint8_t> getDyldChainedFixups() const;
+  ArrayRef<uint8_t> getDyldExportsTrie() const;
   SmallVector<uint64_t> getFunctionStarts() const;
   ArrayRef<uint8_t> getUuid() const;
 
   StringRef getStringTableData() const;
   bool is64Bit() const;
   void ReadULEB128s(uint64_t Index, SmallVectorImpl<uint64_t> &Out) const;
 
   static StringRef guessLibraryShortName(StringRef Name, bool &isFramework,
private:
   BuildToolList BuildTools;
   mutable LibraryShortName LibrariesShortNames;
   std::unique_ptr<BindRebaseSegInfo> BindRebaseSectionTable;
   const char *SymtabLoadCmd = nullptr;
   const char *DysymtabLoadCmd = nullptr;
   const char *DataInCodeLoadCmd = nullptr;
   const char *LinkOptHintsLoadCmd = nullptr;
   const char *DyldInfoLoadCmd = nullptr;
+  const char *DyldChainedFixupsLoadCmd = nullptr;
+  const char *DyldExportsTrieLoadCmd = nullptr;
   const char *FuncStartsLoadCmd = nullptr;
   const char *UuidLoadCmd = nullptr;
   bool HasPageZeroSegment = false;
 };
 
 /// DiceRef
 inline DiceRef::DiceRef(DataRefImpl DiceP, const ObjectFile *Owner)
   : DicePimpl(DiceP) , OwningObject(Owner) {}

llvm/include/llvm/ObjectYAML/MachOYAML.h

struct LinkEditData {
   std::vector<MachOYAML::RebaseOpcode> RebaseOpcodes;
   std::vector<MachOYAML::BindOpcode> BindOpcodes;
   std::vector<MachOYAML::BindOpcode> WeakBindOpcodes;
   std::vector<MachOYAML::BindOpcode> LazyBindOpcodes;
   MachOYAML::ExportEntry ExportTrie;
   std::vector<NListEntry> NameList;
   std::vector<StringRef> StringTable;
   std::vector<yaml::Hex32> IndirectSymbols;
+  std::vector<yaml::Hex8> ChainedFixups;
+  std::vector<yaml::Hex8> DyldExportsTrie;
   std::vector<yaml::Hex64> FunctionStarts;
 
   bool isEmpty() const;
 };
 
 struct Object {
   bool IsLittleEndian;
   FileHeader Header;

llvm/lib/Object/MachOObjectFile.cpp

for (unsigned I = 0; I < LoadCommandCount; ++I) {
     } else if (Load.C.cmd == MachO::LC_DYLD_INFO) {
       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
                                       "LC_DYLD_INFO", Elements)))
         return;
     } else if (Load.C.cmd == MachO::LC_DYLD_INFO_ONLY) {
       if ((Err = checkDyldInfoCommand(*this, Load, I, &DyldInfoLoadCmd,
                                       "LC_DYLD_INFO_ONLY", Elements)))
         return;
+    } else if (Load.C.cmd == MachO::LC_DYLD_CHAINED_FIXUPS) {
+      if ((Err = checkLinkeditDataCommand(
+               *this, Load, I, &DyldChainedFixupsLoadCmd,
+               "LC_DYLD_CHAINED_FIXUPS", Elements, "chained fixups data")))
+        return;
+    } else if (Load.C.cmd == MachO::LC_DYLD_EXPORTS_TRIE) {
+      if ((Err = checkLinkeditDataCommand(
+               *this, Load, I, &DyldExportsTrieLoadCmd, "LC_DYLD_EXPORTS_TRIE",
+               Elements, "exports trie data")))
+        return;
     } else if (Load.C.cmd == MachO::LC_UUID) {
       if (Load.C.cmdsize != sizeof(MachO::uuid_command)) {
         Err = malformedError("LC_UUID command " + Twine(I) + " has incorrect "
                              "cmdsize");
         return;
       }
       if (UuidLoadCmd) {
         Err = malformedError("more than one LC_UUID command");
if (Load.C.cmd == MachO::LC_SYMTAB) {
         return;
       }
       UnixThreadLoadCmd = Load.Ptr;
     } else if (Load.C.cmd == MachO::LC_THREAD) {
       if ((Err = checkThreadCommand(*this, Load, I, "LC_THREAD")))
         return;
     // Note: LC_TWOLEVEL_HINTS is really obsolete and is not supported.
     } else if (Load.C.cmd == MachO::LC_TWOLEVEL_HINTS) {
-       if ((Err = checkTwoLevelHintsCommand(*this, Load, I,
-                                            &TwoLevelHintsLoadCmd, Elements)))
-         return;
     } else if (Load.C.cmd == MachO::LC_IDENT) {
       // Note: LC_IDENT is ignored.
       continue;
     } else if (isLoadCommandObsolete(Load.C.cmd)) {
       Err = malformedError("load command " + Twine(I) + " for cmd value of: " +
                            Twine(Load.C.cmd) + " is obsolete and not "
                            "supported");
       return;
ArrayRef<uint8_t> MachOObjectFile::getDyldInfoExportsTrie() const {
   if (!DyldInfoOrErr)
     return None;
   MachO::dyld_info_command DyldInfo = DyldInfoOrErr.get();
   const uint8_t *Ptr =
       reinterpret_cast<const uint8_t *>(getPtr(*this, DyldInfo.export_off));
   return makeArrayRef(Ptr, DyldInfo.export_size);
 }
 
+ArrayRef<uint8_t> MachOObjectFile::getDyldChainedFixups() const {
+  if (!DyldChainedFixupsLoadCmd)
+    return None;
+
+  auto InfoOrErr = getStructOrErr<MachO::linkedit_data_command>(
+      *this, DyldChainedFixupsLoadCmd);
+  if (!InfoOrErr)
+    return None;
+
+  MachO::linkedit_data_command Info = InfoOrErr.get();
+  const uint8_t *Ptr =
+      reinterpret_cast<const uint8_t *>(getPtr(*this, Info.dataoff));
+  return makeArrayRef(Ptr, Info.datasize);
+}
+
+ArrayRef<uint8_t> MachOObjectFile::getDyldExportsTrie() const {
+  if (!DyldExportsTrieLoadCmd)
+    return None;
+
+  auto InfoOrErr = getStructOrErr<MachO::linkedit_data_command>(
+      *this, DyldExportsTrieLoadCmd);
+  if (!InfoOrErr)
+    return None;
+
+  MachO::linkedit_data_command Info = InfoOrErr.get();
+  const uint8_t *Ptr =
+      reinterpret_cast<const uint8_t *>(getPtr(*this, Info.dataoff));
+  return makeArrayRef(Ptr, Info.datasize);
+}
+
 SmallVector<uint64_t> MachOObjectFile::getFunctionStarts() const {
   if (!FuncStartsLoadCmd)
     return {};
 
   auto InfoOrErr =
       getStructOrErr<MachO::linkedit_data_command>(*this, FuncStartsLoadCmd);
   if (!InfoOrErr)
     return {};

llvm/lib/ObjectYAML/MachOEmitter.cpp

private:
   void writeRebaseOpcodes(raw_ostream &OS);
   void writeBasicBindOpcodes(raw_ostream &OS);
   void writeWeakBindOpcodes(raw_ostream &OS);
   void writeLazyBindOpcodes(raw_ostream &OS);
   void writeNameList(raw_ostream &OS);
   void writeStringTable(raw_ostream &OS);
   void writeExportTrie(raw_ostream &OS);
   void writeDynamicSymbolTable(raw_ostream &OS);
+  void writeChainedFixups(raw_ostream &OS);
+  void writeDyldExportsTrie(raw_ostream &OS);
   void writeFunctionStarts(raw_ostream &OS);
 
   void dumpExportEntry(raw_ostream &OS, MachOYAML::ExportEntry &Entry);
   void ZeroToOffset(raw_ostream &OS, size_t offset);
 
   MachOYAML::Object &Obj;
   bool is64Bit;
   uint64_t fileStart;

 void MachOWriter::writeLinkEditData(raw_ostream &OS) {
   typedef void (MachOWriter::*writeHandler)(raw_ostream &);
   typedef std::pair<uint64_t, writeHandler> writeOperation;
   std::vector<writeOperation> WriteQueue;
 
   MachO::dyld_info_command *DyldInfoOnlyCmd = nullptr;
   MachO::symtab_command *SymtabCmd = nullptr;
   MachO::dysymtab_command *DSymtabCmd = nullptr;
+  MachO::linkedit_data_command *ChainedFixupsCmd = nullptr;
+  MachO::linkedit_data_command *DyldExportsTrieCmd = nullptr;
   MachO::linkedit_data_command *FunctionStartsCmd = nullptr;
   for (auto &LC : Obj.LoadCommands) {
     switch (LC.Data.load_command_data.cmd) {
     case MachO::LC_SYMTAB:
       SymtabCmd = &LC.Data.symtab_command_data;
       WriteQueue.push_back(
           std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList));
       WriteQueue.push_back(
case MachO::LC_DYLD_INFO_ONLY:
       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off,
                                           &MachOWriter::writeExportTrie));
       break;
     case MachO::LC_DYSYMTAB:
       DSymtabCmd = &LC.Data.dysymtab_command_data;
       WriteQueue.push_back(std::make_pair(
           DSymtabCmd->indirectsymoff, &MachOWriter::writeDynamicSymbolTable));
       break;
+    case MachO::LC_DYLD_CHAINED_FIXUPS:
+      ChainedFixupsCmd = &LC.Data.linkedit_data_command_data;
+      WriteQueue.push_back(std::make_pair(ChainedFixupsCmd->dataoff,
+                                          &MachOWriter::writeChainedFixups));
+      break;
+    case MachO::LC_DYLD_EXPORTS_TRIE:
+      DyldExportsTrieCmd = &LC.Data.linkedit_data_command_data;
+      WriteQueue.push_back(std::make_pair(DyldExportsTrieCmd->dataoff,
+                                          &MachOWriter::writeDyldExportsTrie));
+      break;
     case MachO::LC_FUNCTION_STARTS:
       FunctionStartsCmd = &LC.Data.linkedit_data_command_data;
       WriteQueue.push_back(std::make_pair(FunctionStartsCmd->dataoff,
                                           &MachOWriter::writeFunctionStarts));
       break;
     }
   }
 

 }
 
 void MachOWriter::writeDynamicSymbolTable(raw_ostream &OS) {
   for (auto Data : Obj.LinkEdit.IndirectSymbols)
     OS.write(reinterpret_cast<const char *>(&Data),
              sizeof(yaml::Hex32::BaseType));
 }
 
+void MachOWriter::writeChainedFixups(raw_ostream &OS) {
+  for (auto Data : Obj.LinkEdit.ChainedFixups)
+    OS.write(reinterpret_cast<const char *>(&Data),
+             sizeof(yaml::Hex8::BaseType));
+}
+
+void MachOWriter::writeDyldExportsTrie(raw_ostream &OS) {
+  for (auto Data : Obj.LinkEdit.DyldExportsTrie)
+    OS.write(reinterpret_cast<const char *>(&Data),
+             sizeof(yaml::Hex8::BaseType));
+}
+
 void MachOWriter::writeFunctionStarts(raw_ostream &OS) {
   uint64_t Addr = 0;
   for (uint64_t NextAddr : Obj.LinkEdit.FunctionStarts) {
     uint64_t Delta = NextAddr - Addr;
     encodeULEB128(Delta, OS);
     Addr = NextAddr;
   }
 

llvm/lib/ObjectYAML/MachOYAML.cpp

 namespace llvm {
 
 MachOYAML::LoadCommand::~LoadCommand() = default;
 
 bool MachOYAML::LinkEditData::isEmpty() const {
   return 0 == RebaseOpcodes.size() + BindOpcodes.size() +
                   WeakBindOpcodes.size() + LazyBindOpcodes.size() +
                   ExportTrie.Children.size() + NameList.size() +
-                  StringTable.size() + FunctionStarts.size();
+                  StringTable.size() + ChainedFixups.size() +
+                  DyldExportsTrie.size() + FunctionStarts.size();
 }
 
 namespace yaml {
 
 void ScalarTraits<char_16>::output(const char_16 &Val, void *,
                                    raw_ostream &Out) {
   auto Len = strnlen(&Val[0], 16);
   Out << StringRef(&Val[0], Len);
void MappingTraits<MachOYAML::LinkEditData>::mapping(
   IO.mapOptional("BindOpcodes", LinkEditData.BindOpcodes);
   IO.mapOptional("WeakBindOpcodes", LinkEditData.WeakBindOpcodes);
   IO.mapOptional("LazyBindOpcodes", LinkEditData.LazyBindOpcodes);
   if (!LinkEditData.ExportTrie.Children.empty() || !IO.outputting())
     IO.mapOptional("ExportTrie", LinkEditData.ExportTrie);
   IO.mapOptional("NameList", LinkEditData.NameList);
   IO.mapOptional("StringTable", LinkEditData.StringTable);
   IO.mapOptional("IndirectSymbols", LinkEditData.IndirectSymbols);
+  IO.mapOptional("ChainedFixups", LinkEditData.ChainedFixups);
+  IO.mapOptional("DyldExportsTrie", LinkEditData.DyldExportsTrie);
   IO.mapOptional("FunctionStarts", LinkEditData.FunctionStarts);
 }
 
 void MappingTraits<MachOYAML::RebaseOpcode>::mapping(
     IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode) {
   IO.mapRequired("Opcode", RebaseOpcode.Opcode);
   IO.mapRequired("Imm", RebaseOpcode.Imm);
   IO.mapOptional("ExtraData", RebaseOpcode.ExtraData);

llvm/test/ObjectYAML/MachO/chained_fixups.yaml

+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x100000C
+  cpusubtype:      0x0
+  filetype:        0x2
+  ncmds:           15
+  sizeofcmds:      728
+  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:            0x100003FA4
+        size:            20
+        offset:          0x3FA4
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         FF4300D1FF0F00B920008052FF430091C0035FD6
+      - sectname:        __unwind_info
+        segname:         __TEXT
+        addr:            0x100003FB8
+        size:            72
+        offset:          0x3FB8
+        align:           2
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x0
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         010000001C000000000000001C000000000000001C00000002000000A43F00003400000034000000B93F00000000000034000000030000000C000100100001000000000000100002
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __LINKEDIT
+    vmaddr:          4294983680
+    vmsize:          16384
+    fileoff:         16384
+    filesize:        176
+    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:        48
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          16496
+    nsyms:           2
+    stroff:          16528
+    strsize:         32
+  - cmd:             LC_DYSYMTAB
+    cmdsize:         80
+    ilocalsym:       0
+    nlocalsym:       0
+    iextdefsym:      0
+    nextdefsym:      2
+    iundefsym:       2
+    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:            F12C9069-0DBE-3980-A652-33D13A52F817
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         32
+    platform:        1
+    minos:           786432
+    sdk:             786688
+    ntools:          1
+    Tools:
+      - tool:            3
+        version:         46596096
+  - cmd:             LC_SOURCE_VERSION
+    cmdsize:         16
+    version:         0
+  - cmd:             LC_MAIN
+    cmdsize:         24
+    entryoff:        16292
+    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:         16488
+    datasize:        8
+  - cmd:             LC_DATA_IN_CODE
+    cmdsize:         16
+    dataoff:         16496
+    datasize:        0
+LinkEditData:
+  NameList:
+    - 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:         4294983588
+  StringTable:
+    - ' '
+    - __mh_execute_header
+    - _main
+    - ''
+    - ''
+    - ''
+    - ''
+  ChainedFixups:   [ 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x30, 0x0,
+                     0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                     0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                     0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                     0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+                     0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]
+  DyldExportsTrie: [ 0x0, 0x1, 0x5F, 0x0, 0x5, 0x0, 0x2, 0x5F, 0x6D, 0x68,
+                     0x5F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x5F,
+                     0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x0, 0x21, 0x6D,
+                     0x61, 0x69, 0x6E, 0x0, 0x25, 0x2, 0x0, 0x0, 0x0, 0x3,
+                     0x0, 0xA4, 0x7F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]
+  FunctionStarts:  [ 0x3FA4 ]
+...
+
+# RUN: yaml2obj %s -o=%t
+# RUN: obj2yaml %t | FileCheck %s
+# CHECK: ChainedFixups:   [ 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x30, 0x0,
+# CHECK:                    0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK:                    0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK:                    0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK:                    0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK: DyldExportsTrie: [ 0x0, 0x1, 0x5F, 0x0, 0x5, 0x0, 0x2, 0x5F, 0x6D, 0x68,
+# CHECK:                    0x5F, 0x65, 0x78, 0x65, 0x63, 0x75, 0x74, 0x65, 0x5F,
+# CHECK:                    0x68, 0x65, 0x61, 0x64, 0x65, 0x72, 0x0, 0x21, 0x6D,
+# CHECK:                    0x61, 0x69, 0x6E, 0x0, 0x25, 0x2, 0x0, 0x0, 0x0, 0x3,
+# CHECK:                    0x0, 0xA4, 0x7F, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]

llvm/tools/obj2yaml/macho2yaml.cpp

class MachODumper {
 
   const object::MachOObjectFile &Obj;
   std::unique_ptr<DWARFContext> DWARFCtx;
   unsigned RawSegment;
   void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y);
   Error dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y);
+  void dumpChainedFixups(std::unique_ptr<MachOYAML::Object> &Y);
+  void dumpDyldExportsTrie(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpFunctionStarts(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes,
                        ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false);
   void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpIndirectSymbols(std::unique_ptr<MachOYAML::Object> &Y);
 
   template <typename SectionType>
void MachODumper::dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y) {
   dumpBindOpcodes(Y->LinkEdit.BindOpcodes, Obj.getDyldInfoBindOpcodes());
   dumpBindOpcodes(Y->LinkEdit.WeakBindOpcodes,
                   Obj.getDyldInfoWeakBindOpcodes());
   dumpBindOpcodes(Y->LinkEdit.LazyBindOpcodes, Obj.getDyldInfoLazyBindOpcodes(),
                   true);
   dumpExportTrie(Y);
   dumpSymbols(Y);
   dumpIndirectSymbols(Y);
+  dumpChainedFixups(Y);
+  dumpDyldExportsTrie(Y);
   dumpFunctionStarts(Y);
 }
 
+void MachODumper::dumpChainedFixups(std::unique_ptr<MachOYAML::Object> &Y) {
+  MachOYAML::LinkEditData &LEData = Y->LinkEdit;
+
+  auto ChainedFixups = Obj.getDyldChainedFixups();
+  for (auto Bytes : ChainedFixups)
+    LEData.ChainedFixups.push_back(Bytes);
+}
+
+void MachODumper::dumpDyldExportsTrie(std::unique_ptr<MachOYAML::Object> &Y) {
+  MachOYAML::LinkEditData &LEData = Y->LinkEdit;
+
+  auto ExportsTrie = Obj.getDyldExportsTrie();
+  for (auto Bytes : ExportsTrie)
+    LEData.DyldExportsTrie.push_back(Bytes);
+}
+
 void MachODumper::dumpFunctionStarts(std::unique_ptr<MachOYAML::Object> &Y) {
   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
 
   auto FunctionStarts = Obj.getFunctionStarts();
   for (auto Addr : FunctionStarts)
     LEData.FunctionStarts.push_back(Addr);
 }