[ObjectYAML] Basic support for chained fixups.

[drodriguez]

Summary

Add basic binary support for chained fixups. This allows basic tests
with chained fixups without trying to create a format for them until the
work on the Object library is considered finished.

[beanz]

Looping in @lhames in case he has any thoughts from Apple.

From a design perspective I'm not sure this is the approach I'd take, but I also don't know that I'm the best person to judge since I'm not going to be the user here.

When I added the initial mach-o support the emphasis was on representing the binary accurately enough to reproduce binary-accurate transformations, but to also have the YAML representation be human readable wherever it could be. This patch really just treats it as binary data, which makes it pretty unreadable.

llvm/lib/ObjectYAML/MachOEmitter.cpp

603

610

617

llvm/tools/obj2yaml/macho2yaml.cpp

630

[drodriguez]

In D134250#3802961, @beanz wrote:

When I added the initial mach-o support the emphasis was on representing the binary accurately enough to reproduce binary-accurate transformations, but to also have the YAML representation be human readable wherever it could be. This patch really just treats it as binary data, which makes it pretty unreadable.

Agree 100%. The need from this come from D133974. I had the need of testing that the data was moved correctly during objcopy, but I don't have the need to inspect the data itself. My hope is that whenever someone has the need to check that the data is actually representing the right thing, they will have the knowledge of what the data represents and how better transform it into YAML. I prefer not to check-in executables in the source tree, but if we don't even want this code as a temporary solution, I think I can work around the need of adding this support.

[drodriguez]

More code style.

[beanz]

In D134250#3803226, @drodriguez wrote:

Agree 100%. The need from this come from D133974. I had the need of testing that the data was moved correctly during objcopy, but I don't have the need to inspect the data itself. My hope is that whenever someone has the need to check that the data is actually representing the right thing, they will have the knowledge of what the data represents and how better transform it into YAML.

Amusingly the only documentation I'm aware of that documents the format of the export trie... is in a file you modified in this change: https://github.com/llvm/llvm-project/blob/main/llvm/tools/obj2yaml/macho2yaml.cpp#L473

[pete]

llvm/lib/ObjectYAML/MachOYAML.cpp

171

Should this be LinkEditData.DyldExportsTrie?

llvm/tools/obj2yaml/macho2yaml.cpp

646

So the exports trie is a little weird. It used to live in the LC_DYLD_INFO/LC_DYLD_INFO_ONLY along with bind opcodes. If the binary is using opcode based fixups, then it is required that the trie come from there, not the LC_DYLD_EXPORTS_TRIE.

If the binary is newer, and uses LC_DYLD_CHAINED_FIXUPS then it is required that the export trie (if there is one) comes from the LC_DYLD_EXPORTS_TRIE.

I don't know if that impacts this code or not, but roughly i'd expect the export trie to be dumped either next to the bind opcodes as part of the LC_DYLD_INFO, or next to the chained fixups as a LC_DYLD_EXPORTS_TRIE. Does this dump method handle both those cases, or just the LC_DYLD_EXPORTS_TRIE case?

[drodriguez]

In D134250#3803983, @beanz wrote:

Amusingly the only documentation I'm aware of that documents the format of the export trie... is in a file you modified in this change: https://github.com/llvm/llvm-project/blob/main/llvm/tools/obj2yaml/macho2yaml.cpp#L473

😆 I think you wanted to use "As usual", and not "Amunsigly". Lacking format documentation seems to be a constant with Mach-O 😆

Do you happen to know if the contents of the newer LC_DYLD_EXPORTS_TRIE have the same format as the previous trie? It seems to me that they look very similar. I wonder if I can reuse a little bit of the code and improve this to have a more human-friendly dump (I will need to modify some code of the Object library first, which seems to not deal with this old place/new place duality).

llvm/lib/ObjectYAML/MachOYAML.cpp

171

Thanks. Good eyes. I did not realize that the initial yaml dump had the same values in both places.

llvm/tools/obj2yaml/macho2yaml.cpp

646

Thanks for the explanation. It clarifies why I could not get one with both LC_DYLD_INFO and LC_DYLD_CHAINED_FIXUPS. I was confuse why there was the design had two structures named almost the same ("exports trie" and a "dyld exports trie").

As you pointed out above, this was doing the wrong thing. I think autocomplete of dyld… found getDyldInfoExportsTrie and I did not realize that I was looking for the wrong piece of the binary. I changed the code to find the LC and dump the contents directly.

This code also only deals with LC_DYLD_EXPORTS_TRIE, since it was the one we started having problems (for the problems see D133974). It seems that the code in dumpExportsTrie and processExportNode dump the other.

[drodriguez]

Fix incorrect mapping. Fix code for dumping the right LC. Fix test

[beanz]

In D134250#3804346, @drodriguez wrote:

Do you happen to know if the contents of the newer LC_DYLD_EXPORTS_TRIE have the same format as the previous trie?

@pete can correct me if I’m wrong, but I believe they are the same.

[pete]

In D134250#3804617, @beanz wrote:

In D134250#3804346, @drodriguez wrote:

Do you happen to know if the contents of the newer LC_DYLD_EXPORTS_TRIE have the same format as the previous trie?

@pete can correct me if I’m wrong, but I believe they are the same.

Yep, exactly the same contents.

[pete]

LGTM. Thanks for doing this!

[Higuoxing]

I'm not familiar with Mach-O object files. I can only give some minor suggestions on your codes.

llvm/lib/ObjectYAML/MachOEmitter.cpp

603

Since Obj.LinkEdit.ChainedFixups is an array of bytes. You can simply serialize it using

if (Obj.LinkEdit.ChainedFixups.size() > 0)
  OS.write(reinterpret_case<const char *>(Obj.LinkEdit.ChainedFixups.data()),
           Obj.LinkEdit.ChainedFixups.size());

610

Ditto.

617

Ditto.

llvm/tools/obj2yaml/macho2yaml.cpp

671

Why not using reinterpret_case<> here?

[beanz]

llvm/tools/obj2yaml/macho2yaml.cpp

671

void* to uint8_t* doesn’t need a reinterpret_cast so it is better to use a static_cast.

[Higuoxing]

llvm/tools/obj2yaml/macho2yaml.cpp

671

Yes, I mean why not just

uint8_t *Bytes = reinterpret_cast<uint8_t *>(&DICE);

[beanz]

llvm/tools/obj2yaml/macho2yaml.cpp

671

Ah, I see. The single reinterpret_cast is probably clearer here. Sorry for the noise.

[drodriguez]

Split into D134569, D134571 and this. Use the feedback provided by Higuoxing

[drodriguez]

Remove pieces related to the export trie to avoid dependency in previous diff.

llvm/include/llvm/ObjectYAML/MachOYAML.h

struct LinkEditData {
   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::Hex64> FunctionStarts;
   std::vector<DataInCodeEntry> DataInCode;
+  std::vector<yaml::Hex8> ChainedFixups;
 
   bool isEmpty() const;
 };
 
 struct Object {
   bool IsLittleEndian;
   FileHeader Header;
   std::vector<LoadCommand> LoadCommands;

llvm/lib/ObjectYAML/MachOEmitter.cpp

private:
   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 writeFunctionStarts(raw_ostream &OS);
+  void writeChainedFixups(raw_ostream &OS);
   void writeDataInCode(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 *FunctionStartsCmd = nullptr;
+  MachO::linkedit_data_command *ChainedFixupsCmd = nullptr;
   MachO::linkedit_data_command *DataInCodeCmd = 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_DYSYMTAB:
       WriteQueue.push_back(std::make_pair(
           DSymtabCmd->indirectsymoff, &MachOWriter::writeDynamicSymbolTable));
       break;
     case MachO::LC_FUNCTION_STARTS:
       FunctionStartsCmd = &LC.Data.linkedit_data_command_data;
       WriteQueue.push_back(std::make_pair(FunctionStartsCmd->dataoff,
                                           &MachOWriter::writeFunctionStarts));
       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_DATA_IN_CODE:
       DataInCodeCmd = &LC.Data.linkedit_data_command_data;
       WriteQueue.push_back(std::make_pair(DataInCodeCmd->dataoff,
                                           &MachOWriter::writeDataInCode));
       break;
     }
   }
 
for (uint64_t NextAddr : Obj.LinkEdit.FunctionStarts) {
     encodeULEB128(Delta, OS);
     Addr = NextAddr;
   }
 
   OS.write('\0');
 }
 
 void MachOWriter::writeDataInCode(raw_ostream &OS) {
   for (const auto &Entry : Obj.LinkEdit.DataInCode) {
     MachO::data_in_code_entry DICE{Entry.Offset, Entry.Length, Entry.Kind};
     if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
       MachO::swapStruct(DICE);
     OS.write(reinterpret_cast<const char *>(&DICE),
              sizeof(MachO::data_in_code_entry));
   }
 }
 
+void MachOWriter::writeChainedFixups(raw_ostream &OS) {
+  if (Obj.LinkEdit.ChainedFixups.size() > 0)
+    OS.write(reinterpret_cast<const char *>(Obj.LinkEdit.ChainedFixups.data()),
+             Obj.LinkEdit.ChainedFixups.size());
+}
+
 class UniversalWriter {
 public:
   UniversalWriter(yaml::YamlObjectFile &ObjectFile)
       : ObjectFile(ObjectFile), fileStart(0) {}
 
   Error writeMachO(raw_ostream &OS);
 
 private:

llvm/lib/ObjectYAML/MachOYAML.cpp

 
 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() +
-                  DataInCode.size();
+                  ChainedFixups.size() + DataInCode.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("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("FunctionStarts", LinkEditData.FunctionStarts);
+  IO.mapOptional("ChainedFixups", LinkEditData.ChainedFixups);
   IO.mapOptional("DataInCode", LinkEditData.DataInCode);
 }
 
 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:         0x1000007
+  cpusubtype:      0x3
+  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:            0x100003FB0
+        size:            8
+        offset:          0x3FB0
+        align:           4
+        reloff:          0x0
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x0
+        reserved2:       0x0
+        reserved3:       0x0
+        content:         C30F1F0000000000
+      - 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:         010000001C000000000000001C000000000000001C00000002000000B03F00003400000034000000B93F00000000000034000000030000000C000100100001000000000000000000
+  - 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:          16504
+    nsyms:           2
+    stroff:          16536
+    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:            362D6303-E0AC-3074-B083-CF48B87DB35D
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         32
+    platform:        1
+    minos:           786432
+    sdk:             787200
+    ntools:          1
+    Tools:
+      - tool:            3
+        version:         50069504
+  - cmd:             LC_SOURCE_VERSION
+    cmdsize:         16
+    version:         0
+  - cmd:             LC_MAIN
+    cmdsize:         24
+    entryoff:        16304
+    stacksize:       0
+  - cmd:             LC_LOAD_DYLIB
+    cmdsize:         56
+    dylib:
+      name:            24
+      timestamp:       2
+      current_version: 85943299
+      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:         0
+    datasize:        0
+LinkEditData:
+  ExportTrie:
+      TerminalSize:    0
+      NodeOffset:      0
+      Name:            ''
+      Flags:           0x0
+      Address:         0x0
+      Other:           0x0
+      ImportName:      ''
+      Children:
+        - TerminalSize:    0
+          NodeOffset:      5
+          Name:            _
+          Flags:           0x0
+          Address:         0x0
+          Other:           0x0
+          ImportName:      ''
+          Children:
+            - TerminalSize:    2
+              NodeOffset:      33
+              Name:            _mh_execute_header
+              Flags:           0x0
+              Address:         0x0
+              Other:           0x0
+              ImportName:      ''
+            - TerminalSize:    3
+              NodeOffset:      37
+              Name:            main
+              Flags:           0x0
+              Address:         0x3F98
+              Other:           0x0
+              ImportName:      ''
+  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:         4294983600
+  StringTable:
+    - ' '
+    - __mh_execute_header
+    - _main
+    - ''
+    - ''
+    - ''
+    - ''
+  FunctionStarts:  [ 0x3FB0 ]
+  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 ]
+...
+
+# RUN: yaml2obj %s | obj2yaml | FileCheck %s
+
+# CHECK:      cmd:             LC_DYLD_CHAINED_FIXUPS
+# CHECK-NEXT: cmdsize:         16
+# CHECK-NEXT: dataoff:         [[#CHAINED_FIXUPS_OFF:]]
+# CHECK-NEXT: datasize:        [[#CHAINED_FIXUPS_SIZE: 56]]
+
+# CHECK:      cmd:             LC_DYLD_EXPORTS_TRIE
+# CHECK-NEXT: cmdsize:         16
+# CHECK-NEXT: dataoff:         [[#EXPORTS_TRIE_OFF: CHAINED_FIXUPS_OFF + CHAINED_FIXUPS_SIZE]]
+# CHECK-NEXT: datasize:        48
+
+## TODO: Need D134571 to check for export trie in LC_DYLD_EXPORTS_TRIE.
+
+# CHECK: ChainedFixups:
+# CHECK-SAME: [ 0x0, 0x0, 0x0, 0x0, 0x20, 0x0, 0x0, 0x0, 0x30, 0x0,
+# CHECK-NEXT:   0x0, 0x0, 0x30, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK-NEXT:   0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK-NEXT:   0x0, 0x0, 0x3, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK-NEXT:   0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0,
+# CHECK-NEXT:   0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ]

llvm/tools/obj2yaml/macho2yaml.cpp

class MachODumper {
   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpRebaseOpcodes(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);
+  void dumpChainedFixups(std::unique_ptr<MachOYAML::Object> &Y);
   void dumpDataInCode(std::unique_ptr<MachOYAML::Object> &Y);
 
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSectionCommon(SectionType Sec,
                                                       size_t SecIndex);
   template <typename SectionType>
   Expected<MachOYAML::Section> constructSection(SectionType Sec,
                                                 size_t SecIndex);
void MachODumper::dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y) {
   dumpBindOpcodes(Y->LinkEdit.WeakBindOpcodes,
                   Obj.getDyldInfoWeakBindOpcodes());
   dumpBindOpcodes(Y->LinkEdit.LazyBindOpcodes, Obj.getDyldInfoLazyBindOpcodes(),
                   true);
   dumpExportTrie(Y);
   dumpSymbols(Y);
   dumpIndirectSymbols(Y);
   dumpFunctionStarts(Y);
+  dumpChainedFixups(Y);
   dumpDataInCode(Y);
 }
 
 void MachODumper::dumpFunctionStarts(std::unique_ptr<MachOYAML::Object> &Y) {
   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
 
   auto FunctionStarts = Obj.getFunctionStarts();
   for (auto Addr : FunctionStarts)

 void MachODumper::dumpIndirectSymbols(std::unique_ptr<MachOYAML::Object> &Y) {
   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
 
   MachO::dysymtab_command DLC = Obj.getDysymtabLoadCommand();
   for (unsigned i = 0; i < DLC.nindirectsyms; ++i)
     LEData.IndirectSymbols.push_back(Obj.getIndirectSymbolTableEntry(DLC, i));
 }
 
+void MachODumper::dumpChainedFixups(std::unique_ptr<MachOYAML::Object> &Y) {
+  MachOYAML::LinkEditData &LEData = Y->LinkEdit;
+
+  for (const auto &LC : Y->LoadCommands) {
+    if (LC.Data.load_command_data.cmd == llvm::MachO::LC_DYLD_CHAINED_FIXUPS) {
+      const MachO::linkedit_data_command &DC =
+          LC.Data.linkedit_data_command_data;
+      if (DC.dataoff) {
+        assert(DC.dataoff < Obj.getData().size());
+        assert(DC.dataoff + DC.datasize <= Obj.getData().size());
+        const char *Bytes = Obj.getData().data() + DC.dataoff;
+        for (size_t Idx = 0; Idx < DC.datasize; Idx++) {
+          LEData.ChainedFixups.push_back(Bytes[Idx]);
+        }
+      }
+      break;
+    }
+  }
+}
+
 void MachODumper::dumpDataInCode(std::unique_ptr<MachOYAML::Object> &Y) {
   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
 
   MachO::linkedit_data_command DIC = Obj.getDataInCodeLoadCommand();
   uint32_t NumEntries = DIC.datasize / sizeof(MachO::data_in_code_entry);
   for (uint32_t Idx = 0; Idx < NumEntries; ++Idx) {
     MachO::data_in_code_entry DICE =
         Obj.getDataInCodeTableEntry(DIC.dataoff, Idx);
     MachOYAML::DataInCodeEntry Entry{DICE.offset, DICE.length, DICE.kind};
     LEData.DataInCode.emplace_back(Entry);
   }
 }
 
 Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj,
                  unsigned RawSegments) {
   std::unique_ptr<DWARFContext> DCtx = DWARFContext::create(Obj);
   MachODumper Dumper(Obj, std::move(DCtx), RawSegments);
   Expected<std::unique_ptr<MachOYAML::Object>> YAML = Dumper.dump();
   if (!YAML)
     return YAML.takeError();
 
   yaml::YamlObjectFile YAMLFile;
   YAMLFile.MachO = std::move(YAML.get());
 
   yaml::Output Yout(Out);
   Yout << YAMLFile;
   return Error::success();
 }
 
 Error macho2yaml(raw_ostream &Out, const object::MachOUniversalBinary &Obj,
                  unsigned RawSegments) {
   yaml::YamlObjectFile YAMLFile;
   YAMLFile.FatMachO.reset(new MachOYAML::UniversalBinary());