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