tools/obj2yaml/macho2yaml.cpp

   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(DWARFContext &DCtx,
  39                        std::unique_ptr<MachOYAML::Object> &Y);
  40   void dumpDebugStrings(DWARFContext &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   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(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 }