1 //===------ macho2yaml.cpp - obj2yaml conversion tool -----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "Error.h"
10 #include "obj2yaml.h"
11 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
12 #include "llvm/Object/MachOUniversal.h"
13 #include "llvm/ObjectYAML/ObjectYAML.h"
14 #include "llvm/Support/ErrorHandling.h"
15 #include "llvm/Support/LEB128.h"
16 
17 #include <string.h> // for memcpy
18 
19 using namespace llvm;
20 
21 class MachODumper {
22 
23   template <typename StructType>
24   const char *processLoadCommandData(
25       MachOYAML::LoadCommand &LC,
26       const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd);
27 
28   const object::MachOObjectFile &Obj;
29   void dumpHeader(std::unique_ptr<MachOYAML::Object> &Y);
30   void dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y);
31   void dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y);
32   void dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y);
33   void dumpBindOpcodes(std::vector<MachOYAML::BindOpcode> &BindOpcodes,
34                        ArrayRef<uint8_t> OpcodeBuffer, bool Lazy = false);
35   void dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y);
36   void dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y);
37   void dumpDebugAbbrev(DWARFContext &DCtx,
38                        std::unique_ptr<MachOYAML::Object> &Y);
39   void dumpDebugStrings(DWARFContext &DCtx,
40                         std::unique_ptr<MachOYAML::Object> &Y);
41 
42 public:
43   MachODumper(const object::MachOObjectFile &O) : Obj(O) {}
44   Expected<std::unique_ptr<MachOYAML::Object>> dump();
45 };
46 
47 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
48   case MachO::LCName:                                                          \
49     memcpy((void *) & (LC.Data.LCStruct##_data), LoadCmd.Ptr,                  \
50            sizeof(MachO::LCStruct));                                           \
51     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)                       \
52       MachO::swapStruct(LC.Data.LCStruct##_data);                              \
53     EndPtr = processLoadCommandData<MachO::LCStruct>(LC, LoadCmd);             \
54     break;
55 
56 template <typename SectionType>
57 MachOYAML::Section constructSectionCommon(SectionType Sec) {
58   MachOYAML::Section TempSec;
59   memcpy(reinterpret_cast<void *>(&TempSec.sectname[0]), &Sec.sectname[0], 16);
60   memcpy(reinterpret_cast<void *>(&TempSec.segname[0]), &Sec.segname[0], 16);
61   TempSec.addr = Sec.addr;
62   TempSec.size = Sec.size;
63   TempSec.offset = Sec.offset;
64   TempSec.align = Sec.align;
65   TempSec.reloff = Sec.reloff;
66   TempSec.nreloc = Sec.nreloc;
67   TempSec.flags = Sec.flags;
68   TempSec.reserved1 = Sec.reserved1;
69   TempSec.reserved2 = Sec.reserved2;
70   TempSec.reserved3 = 0;
71   return TempSec;
72 }
73 
74 template <typename SectionType>
75 MachOYAML::Section constructSection(SectionType Sec);
76 
77 template <> MachOYAML::Section constructSection(MachO::section Sec) {
78   MachOYAML::Section TempSec = constructSectionCommon(Sec);
79   TempSec.reserved3 = 0;
80   return TempSec;
81 }
82 
83 template <> MachOYAML::Section constructSection(MachO::section_64 Sec) {
84   MachOYAML::Section TempSec = constructSectionCommon(Sec);
85   TempSec.reserved3 = Sec.reserved3;
86   return TempSec;
87 }
88 
89 template <typename SectionType, typename SegmentType>
90 const char *
91 extractSections(const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd,
92                 std::vector<MachOYAML::Section> &Sections,
93                 bool IsLittleEndian) {
94   auto End = LoadCmd.Ptr + LoadCmd.C.cmdsize;
95   const SectionType *Curr =
96       reinterpret_cast<const SectionType *>(LoadCmd.Ptr + sizeof(SegmentType));
97   for (; reinterpret_cast<const void *>(Curr) < End; Curr++) {
98     if (IsLittleEndian != sys::IsLittleEndianHost) {
99       SectionType Sec;
100       memcpy((void *)&Sec, Curr, sizeof(SectionType));
101       MachO::swapStruct(Sec);
102       Sections.push_back(constructSection(Sec));
103     } else {
104       Sections.push_back(constructSection(*Curr));
105     }
106   }
107   return reinterpret_cast<const char *>(Curr);
108 }
109 
110 template <typename StructType>
111 const char *MachODumper::processLoadCommandData(
112     MachOYAML::LoadCommand &LC,
113     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
114   return LoadCmd.Ptr + sizeof(StructType);
115 }
116 
117 template <>
118 const char *MachODumper::processLoadCommandData<MachO::segment_command>(
119     MachOYAML::LoadCommand &LC,
120     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
121   return extractSections<MachO::section, MachO::segment_command>(
122       LoadCmd, LC.Sections, Obj.isLittleEndian());
123 }
124 
125 template <>
126 const char *MachODumper::processLoadCommandData<MachO::segment_command_64>(
127     MachOYAML::LoadCommand &LC,
128     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
129   return extractSections<MachO::section_64, MachO::segment_command_64>(
130       LoadCmd, LC.Sections, Obj.isLittleEndian());
131 }
132 
133 template <typename StructType>
134 const char *
135 readString(MachOYAML::LoadCommand &LC,
136            const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
137   auto Start = LoadCmd.Ptr + sizeof(StructType);
138   auto MaxSize = LoadCmd.C.cmdsize - sizeof(StructType);
139   auto Size = strnlen(Start, MaxSize);
140   LC.PayloadString = StringRef(Start, Size).str();
141   return Start + Size;
142 }
143 
144 template <>
145 const char *MachODumper::processLoadCommandData<MachO::dylib_command>(
146     MachOYAML::LoadCommand &LC,
147     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
148   return readString<MachO::dylib_command>(LC, LoadCmd);
149 }
150 
151 template <>
152 const char *MachODumper::processLoadCommandData<MachO::dylinker_command>(
153     MachOYAML::LoadCommand &LC,
154     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
155   return readString<MachO::dylinker_command>(LC, LoadCmd);
156 }
157 
158 template <>
159 const char *MachODumper::processLoadCommandData<MachO::rpath_command>(
160     MachOYAML::LoadCommand &LC,
161     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
162   return readString<MachO::rpath_command>(LC, LoadCmd);
163 }
164 
165 template <>
166 const char *MachODumper::processLoadCommandData<MachO::build_version_command>(
167     MachOYAML::LoadCommand &LC,
168     const llvm::object::MachOObjectFile::LoadCommandInfo &LoadCmd) {
169   auto Start = LoadCmd.Ptr + sizeof(MachO::build_version_command);
170   auto NTools = LC.Data.build_version_command_data.ntools;
171   for (unsigned i = 0; i < NTools; ++i) {
172     auto Curr = Start + i * sizeof(MachO::build_tool_version);
173     MachO::build_tool_version BV;
174     memcpy((void *)&BV, Curr, sizeof(MachO::build_tool_version));
175     if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
176       MachO::swapStruct(BV);
177     LC.Tools.push_back(BV);
178   }
179   return Start + NTools * sizeof(MachO::build_tool_version);
180 }
181 
182 Expected<std::unique_ptr<MachOYAML::Object>> MachODumper::dump() {
183   auto Y = std::make_unique<MachOYAML::Object>();
184   Y->IsLittleEndian = Obj.isLittleEndian();
185   dumpHeader(Y);
186   dumpLoadCommands(Y);
187   dumpLinkEdit(Y);
188 
189   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
190   if (auto Err = dwarf2yaml(*DICtx, Y->DWARF))
191     return errorCodeToError(Err);
192   return std::move(Y);
193 }
194 
195 void MachODumper::dumpHeader(std::unique_ptr<MachOYAML::Object> &Y) {
196   Y->Header.magic = Obj.getHeader().magic;
197   Y->Header.cputype = Obj.getHeader().cputype;
198   Y->Header.cpusubtype = Obj.getHeader().cpusubtype;
199   Y->Header.filetype = Obj.getHeader().filetype;
200   Y->Header.ncmds = Obj.getHeader().ncmds;
201   Y->Header.sizeofcmds = Obj.getHeader().sizeofcmds;
202   Y->Header.flags = Obj.getHeader().flags;
203   Y->Header.reserved = 0;
204 }
205 
206 void MachODumper::dumpLoadCommands(std::unique_ptr<MachOYAML::Object> &Y) {
207   for (auto LoadCmd : Obj.load_commands()) {
208     MachOYAML::LoadCommand LC;
209     const char *EndPtr = LoadCmd.Ptr;
210     switch (LoadCmd.C.cmd) {
211     default:
212       memcpy((void *)&(LC.Data.load_command_data), LoadCmd.Ptr,
213              sizeof(MachO::load_command));
214       if (Obj.isLittleEndian() != sys::IsLittleEndianHost)
215         MachO::swapStruct(LC.Data.load_command_data);
216       EndPtr = processLoadCommandData<MachO::load_command>(LC, LoadCmd);
217       break;
218 #include "llvm/BinaryFormat/MachO.def"
219     }
220     auto RemainingBytes = LoadCmd.C.cmdsize - (EndPtr - LoadCmd.Ptr);
221     if (!std::all_of(EndPtr, &EndPtr[RemainingBytes],
222                      [](const char C) { return C == 0; })) {
223       LC.PayloadBytes.insert(LC.PayloadBytes.end(), EndPtr,
224                              &EndPtr[RemainingBytes]);
225       RemainingBytes = 0;
226     }
227     LC.ZeroPadBytes = RemainingBytes;
228     Y->LoadCommands.push_back(std::move(LC));
229   }
230 }
231 
232 void MachODumper::dumpLinkEdit(std::unique_ptr<MachOYAML::Object> &Y) {
233   dumpRebaseOpcodes(Y);
234   dumpBindOpcodes(Y->LinkEdit.BindOpcodes, Obj.getDyldInfoBindOpcodes());
235   dumpBindOpcodes(Y->LinkEdit.WeakBindOpcodes,
236                   Obj.getDyldInfoWeakBindOpcodes());
237   dumpBindOpcodes(Y->LinkEdit.LazyBindOpcodes, Obj.getDyldInfoLazyBindOpcodes(),
238                   true);
239   dumpExportTrie(Y);
240   dumpSymbols(Y);
241 }
242 
243 void MachODumper::dumpRebaseOpcodes(std::unique_ptr<MachOYAML::Object> &Y) {
244   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
245 
246   auto RebaseOpcodes = Obj.getDyldInfoRebaseOpcodes();
247   for (auto OpCode = RebaseOpcodes.begin(); OpCode != RebaseOpcodes.end();
248        ++OpCode) {
249     MachOYAML::RebaseOpcode RebaseOp;
250     RebaseOp.Opcode =
251         static_cast<MachO::RebaseOpcode>(*OpCode & MachO::REBASE_OPCODE_MASK);
252     RebaseOp.Imm = *OpCode & MachO::REBASE_IMMEDIATE_MASK;
253 
254     unsigned Count;
255     uint64_t ULEB = 0;
256 
257     switch (RebaseOp.Opcode) {
258     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB:
259 
260       ULEB = decodeULEB128(OpCode + 1, &Count);
261       RebaseOp.ExtraData.push_back(ULEB);
262       OpCode += Count;
263       LLVM_FALLTHROUGH;
264     // Intentionally no break here -- This opcode has two ULEB values
265     case MachO::REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
266     case MachO::REBASE_OPCODE_ADD_ADDR_ULEB:
267     case MachO::REBASE_OPCODE_DO_REBASE_ULEB_TIMES:
268     case MachO::REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB:
269 
270       ULEB = decodeULEB128(OpCode + 1, &Count);
271       RebaseOp.ExtraData.push_back(ULEB);
272       OpCode += Count;
273       break;
274     default:
275       break;
276     }
277 
278     LEData.RebaseOpcodes.push_back(RebaseOp);
279 
280     if (RebaseOp.Opcode == MachO::REBASE_OPCODE_DONE)
281       break;
282   }
283 }
284 
285 StringRef ReadStringRef(const uint8_t *Start) {
286   const uint8_t *Itr = Start;
287   for (; *Itr; ++Itr)
288     ;
289   return StringRef(reinterpret_cast<const char *>(Start), Itr - Start);
290 }
291 
292 void MachODumper::dumpBindOpcodes(
293     std::vector<MachOYAML::BindOpcode> &BindOpcodes,
294     ArrayRef<uint8_t> OpcodeBuffer, bool Lazy) {
295   for (auto OpCode = OpcodeBuffer.begin(); OpCode != OpcodeBuffer.end();
296        ++OpCode) {
297     MachOYAML::BindOpcode BindOp;
298     BindOp.Opcode =
299         static_cast<MachO::BindOpcode>(*OpCode & MachO::BIND_OPCODE_MASK);
300     BindOp.Imm = *OpCode & MachO::BIND_IMMEDIATE_MASK;
301 
302     unsigned Count;
303     uint64_t ULEB = 0;
304     int64_t SLEB = 0;
305 
306     switch (BindOp.Opcode) {
307     case MachO::BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
308       ULEB = decodeULEB128(OpCode + 1, &Count);
309       BindOp.ULEBExtraData.push_back(ULEB);
310       OpCode += Count;
311       LLVM_FALLTHROUGH;
312     // Intentionally no break here -- this opcode has two ULEB values
313 
314     case MachO::BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB:
315     case MachO::BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
316     case MachO::BIND_OPCODE_ADD_ADDR_ULEB:
317     case MachO::BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
318       ULEB = decodeULEB128(OpCode + 1, &Count);
319       BindOp.ULEBExtraData.push_back(ULEB);
320       OpCode += Count;
321       break;
322 
323     case MachO::BIND_OPCODE_SET_ADDEND_SLEB:
324       SLEB = decodeSLEB128(OpCode + 1, &Count);
325       BindOp.SLEBExtraData.push_back(SLEB);
326       OpCode += Count;
327       break;
328 
329     case MachO::BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM:
330       BindOp.Symbol = ReadStringRef(OpCode + 1);
331       OpCode += BindOp.Symbol.size() + 1;
332       break;
333     default:
334       break;
335     }
336 
337     BindOpcodes.push_back(BindOp);
338 
339     // Lazy bindings have DONE opcodes between operations, so we need to keep
340     // processing after a DONE.
341     if (!Lazy && BindOp.Opcode == MachO::BIND_OPCODE_DONE)
342       break;
343   }
344 }
345 
346 /*!
347  * /brief processes a node from the export trie, and its children.
348  *
349  * To my knowledge there is no documentation of the encoded format of this data
350  * other than in the heads of the Apple linker engineers. To that end hopefully
351  * this comment and the implementation below can serve to light the way for
352  * anyone crazy enough to come down this path in the future.
353  *
354  * This function reads and preserves the trie structure of the export trie. To
355  * my knowledge there is no code anywhere else that reads the data and preserves
356  * the Trie. LD64 (sources available at opensource.apple.com) has a similar
357  * implementation that parses the export trie into a vector. That code as well
358  * as LLVM's libObject MachO implementation were the basis for this.
359  *
360  * The export trie is an encoded trie. The node serialization is a bit awkward.
361  * The below pseudo-code is the best description I've come up with for it.
362  *
363  * struct SerializedNode {
364  *   ULEB128 TerminalSize;
365  *   struct TerminalData { <-- This is only present if TerminalSize > 0
366  *     ULEB128 Flags;
367  *     ULEB128 Address; <-- Present if (! Flags & REEXPORT )
368  *     ULEB128 Other; <-- Present if ( Flags & REEXPORT ||
369  *                                     Flags & STUB_AND_RESOLVER )
370  *     char[] ImportName; <-- Present if ( Flags & REEXPORT )
371  *   }
372  *   uint8_t ChildrenCount;
373  *   Pair<char[], ULEB128> ChildNameOffsetPair[ChildrenCount];
374  *   SerializedNode Children[ChildrenCount]
375  * }
376  *
377  * Terminal nodes are nodes that represent actual exports. They can appear
378  * anywhere in the tree other than at the root; they do not need to be leaf
379  * nodes. When reading the data out of the trie this routine reads it in-order,
380  * but it puts the child names and offsets directly into the child nodes. This
381  * results in looping over the children twice during serialization and
382  * de-serialization, but it makes the YAML representation more human readable.
383  *
384  * Below is an example of the graph from a "Hello World" executable:
385  *
386  * -------
387  * | ''  |
388  * -------
389  *    |
390  * -------
391  * | '_' |
392  * -------
393  *    |
394  *    |----------------------------------------|
395  *    |                                        |
396  *  ------------------------      ---------------------
397  *  | '_mh_execute_header' |      | 'main'            |
398  *  | Flags: 0x00000000    |      | Flags: 0x00000000 |
399  *  | Addr:  0x00000000    |      | Addr:  0x00001160 |
400  *  ------------------------      ---------------------
401  *
402  * This graph represents the trie for the exports "__mh_execute_header" and
403  * "_main". In the graph only the "_main" and "__mh_execute_header" nodes are
404  * terminal.
405 */
406 
407 const uint8_t *processExportNode(const uint8_t *CurrPtr,
408                                  const uint8_t *const End,
409                                  MachOYAML::ExportEntry &Entry) {
410   if (CurrPtr >= End)
411     return CurrPtr;
412   unsigned Count = 0;
413   Entry.TerminalSize = decodeULEB128(CurrPtr, &Count);
414   CurrPtr += Count;
415   if (Entry.TerminalSize != 0) {
416     Entry.Flags = decodeULEB128(CurrPtr, &Count);
417     CurrPtr += Count;
418     if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
419       Entry.Address = 0;
420       Entry.Other = decodeULEB128(CurrPtr, &Count);
421       CurrPtr += Count;
422       Entry.ImportName = std::string(reinterpret_cast<const char *>(CurrPtr));
423     } else {
424       Entry.Address = decodeULEB128(CurrPtr, &Count);
425       CurrPtr += Count;
426       if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER) {
427         Entry.Other = decodeULEB128(CurrPtr, &Count);
428         CurrPtr += Count;
429       } else
430         Entry.Other = 0;
431     }
432   }
433   uint8_t childrenCount = *CurrPtr++;
434   if (childrenCount == 0)
435     return CurrPtr;
436 
437   Entry.Children.insert(Entry.Children.begin(), (size_t)childrenCount,
438                         MachOYAML::ExportEntry());
439   for (auto &Child : Entry.Children) {
440     Child.Name = std::string(reinterpret_cast<const char *>(CurrPtr));
441     CurrPtr += Child.Name.length() + 1;
442     Child.NodeOffset = decodeULEB128(CurrPtr, &Count);
443     CurrPtr += Count;
444   }
445   for (auto &Child : Entry.Children) {
446     CurrPtr = processExportNode(CurrPtr, End, Child);
447   }
448   return CurrPtr;
449 }
450 
451 void MachODumper::dumpExportTrie(std::unique_ptr<MachOYAML::Object> &Y) {
452   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
453   auto ExportsTrie = Obj.getDyldInfoExportsTrie();
454   processExportNode(ExportsTrie.begin(), ExportsTrie.end(), LEData.ExportTrie);
455 }
456 
457 template <typename nlist_t>
458 MachOYAML::NListEntry constructNameList(const nlist_t &nlist) {
459   MachOYAML::NListEntry NL;
460   NL.n_strx = nlist.n_strx;
461   NL.n_type = nlist.n_type;
462   NL.n_sect = nlist.n_sect;
463   NL.n_desc = nlist.n_desc;
464   NL.n_value = nlist.n_value;
465   return NL;
466 }
467 
468 void MachODumper::dumpSymbols(std::unique_ptr<MachOYAML::Object> &Y) {
469   MachOYAML::LinkEditData &LEData = Y->LinkEdit;
470 
471   for (auto Symbol : Obj.symbols()) {
472     MachOYAML::NListEntry NLE =
473         Obj.is64Bit()
474             ? constructNameList<MachO::nlist_64>(
475                   Obj.getSymbol64TableEntry(Symbol.getRawDataRefImpl()))
476             : constructNameList<MachO::nlist>(
477                   Obj.getSymbolTableEntry(Symbol.getRawDataRefImpl()));
478     LEData.NameList.push_back(NLE);
479   }
480 
481   StringRef RemainingTable = Obj.getStringTableData();
482   while (RemainingTable.size() > 0) {
483     auto SymbolPair = RemainingTable.split('\0');
484     RemainingTable = SymbolPair.second;
485     LEData.StringTable.push_back(SymbolPair.first);
486   }
487 }
488 
489 Error macho2yaml(raw_ostream &Out, const object::MachOObjectFile &Obj) {
490   MachODumper Dumper(Obj);
491   Expected<std::unique_ptr<MachOYAML::Object>> YAML = Dumper.dump();
492   if (!YAML)
493     return YAML.takeError();
494 
495   yaml::YamlObjectFile YAMLFile;
496   YAMLFile.MachO = std::move(YAML.get());
497 
498   yaml::Output Yout(Out);
499   Yout << YAMLFile;
500   return Error::success();
501 }
502 
503 Error macho2yaml(raw_ostream &Out, const object::MachOUniversalBinary &Obj) {
504   yaml::YamlObjectFile YAMLFile;
505   YAMLFile.FatMachO.reset(new MachOYAML::UniversalBinary());
506   MachOYAML::UniversalBinary &YAML = *YAMLFile.FatMachO;
507   YAML.Header.magic = Obj.getMagic();
508   YAML.Header.nfat_arch = Obj.getNumberOfObjects();
509 
510   for (auto Slice : Obj.objects()) {
511     MachOYAML::FatArch arch;
512     arch.cputype = Slice.getCPUType();
513     arch.cpusubtype = Slice.getCPUSubType();
514     arch.offset = Slice.getOffset();
515     arch.size = Slice.getSize();
516     arch.align = Slice.getAlign();
517     arch.reserved = Slice.getReserved();
518     YAML.FatArchs.push_back(arch);
519 
520     auto SliceObj = Slice.getAsObjectFile();
521     if (!SliceObj)
522       return SliceObj.takeError();
523 
524     MachODumper Dumper(*SliceObj.get());
525     Expected<std::unique_ptr<MachOYAML::Object>> YAMLObj = Dumper.dump();
526     if (!YAMLObj)
527       return YAMLObj.takeError();
528     YAML.Slices.push_back(*YAMLObj.get());
529   }
530 
531   yaml::Output Yout(Out);
532   Yout << YAML;
533   return Error::success();
534 }
535 
536 std::error_code macho2yaml(raw_ostream &Out, const object::Binary &Binary) {
537   if (const auto *MachOObj = dyn_cast<object::MachOUniversalBinary>(&Binary)) {
538     if (auto Err = macho2yaml(Out, *MachOObj)) {
539       return errorToErrorCode(std::move(Err));
540     }
541     return obj2yaml_error::success;
542   }
543 
544   if (const auto *MachOObj = dyn_cast<object::MachOObjectFile>(&Binary)) {
545     if (auto Err = macho2yaml(Out, *MachOObj)) {
546       return errorToErrorCode(std::move(Err));
547     }
548     return obj2yaml_error::success;
549   }
550 
551   return obj2yaml_error::unsupported_obj_file_format;
552 }
553