llvm/lib/ObjectYAML/MachOEmitter.cpp

   1 //===- yaml2macho - Convert YAML to a Mach object file --------------------===//
   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 /// \file
  10 /// The Mach component of yaml2obj.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/BinaryFormat/MachO.h"
  15 #include "llvm/ObjectYAML/DWARFEmitter.h"
  16 #include "llvm/ObjectYAML/ObjectYAML.h"
  17 #include "llvm/ObjectYAML/yaml2obj.h"
  18 #include "llvm/Support/Errc.h"
  19 #include "llvm/Support/Error.h"
  20 #include "llvm/Support/FormatVariadic.h"
  21 #include "llvm/Support/LEB128.h"
  22 #include "llvm/Support/YAMLTraits.h"
  23 #include "llvm/Support/raw_ostream.h"
  24
  25 #include "llvm/Support/Format.h"
  26
  27 using namespace llvm;
  28
  29 namespace {
  30
  31 class MachOWriter {
  32 public:
  33   MachOWriter(MachOYAML::Object &Obj) : Obj(Obj), fileStart(0) {
  34     is64Bit = Obj.Header.magic == MachO::MH_MAGIC_64 ||
  35               Obj.Header.magic == MachO::MH_CIGAM_64;
  36     memset(reinterpret_cast<void *>(&Header), 0, sizeof(MachO::mach_header_64));
  37   }
  38
  39   Error writeMachO(raw_ostream &OS);
  40
  41 private:
  42   void writeHeader(raw_ostream &OS);
  43   void writeLoadCommands(raw_ostream &OS);
  44   Error writeSectionData(raw_ostream &OS);
  45   void writeRelocations(raw_ostream &OS);
  46   void writeLinkEditData(raw_ostream &OS);
  47
  48   void writeBindOpcodes(raw_ostream &OS,
  49                         std::vector<MachOYAML::BindOpcode> &BindOpcodes);
  50   // LinkEdit writers
  51   void writeRebaseOpcodes(raw_ostream &OS);
  52   void writeBasicBindOpcodes(raw_ostream &OS);
  53   void writeWeakBindOpcodes(raw_ostream &OS);
  54   void writeLazyBindOpcodes(raw_ostream &OS);
  55   void writeNameList(raw_ostream &OS);
  56   void writeStringTable(raw_ostream &OS);
  57   void writeExportTrie(raw_ostream &OS);
  58   void writeDynamicSymbolTable(raw_ostream &OS);
  59   void writeFunctionStarts(raw_ostream &OS);
  60   void writeChainedFixups(raw_ostream &OS);
  61   void writeDyldExportsTrie(raw_ostream &OS);
  62   void writeDataInCode(raw_ostream &OS);
  63
  64   void dumpExportEntry(raw_ostream &OS, MachOYAML::ExportEntry &Entry);
  65   void ZeroToOffset(raw_ostream &OS, size_t offset);
  66
  67   MachOYAML::Object &Obj;
  68   bool is64Bit;
  69   uint64_t fileStart;
  70   MachO::mach_header_64 Header;
  71
  72   // Old PPC Object Files didn't have __LINKEDIT segments, the data was just
  73   // stuck at the end of the file.
  74   bool FoundLinkEditSeg = false;
  75 };
  76
  77 Error MachOWriter::writeMachO(raw_ostream &OS) {
  78   fileStart = OS.tell();
  79   writeHeader(OS);
  80   writeLoadCommands(OS);
  81   if (Error Err = writeSectionData(OS))
  82     return Err;
  83   writeRelocations(OS);
  84   if (!FoundLinkEditSeg)
  85     writeLinkEditData(OS);
  86   return Error::success();
  87 }
  88
  89 void MachOWriter::writeHeader(raw_ostream &OS) {
  90   Header.magic = Obj.Header.magic;
  91   Header.cputype = Obj.Header.cputype;
  92   Header.cpusubtype = Obj.Header.cpusubtype;
  93   Header.filetype = Obj.Header.filetype;
  94   Header.ncmds = Obj.Header.ncmds;
  95   Header.sizeofcmds = Obj.Header.sizeofcmds;
  96   Header.flags = Obj.Header.flags;
  97   Header.reserved = Obj.Header.reserved;
  98
  99   if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
 100     MachO::swapStruct(Header);
 101
 102   auto header_size =
 103       is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
 104   OS.write((const char *)&Header, header_size);
 105 }
 106
 107 template <typename SectionType>
 108 SectionType constructSection(const MachOYAML::Section &Sec) {
 109   SectionType TempSec;
 110   memcpy(reinterpret_cast<void *>(&TempSec.sectname[0]), &Sec.sectname[0], 16);
 111   memcpy(reinterpret_cast<void *>(&TempSec.segname[0]), &Sec.segname[0], 16);
 112   TempSec.addr = Sec.addr;
 113   TempSec.size = Sec.size;
 114   TempSec.offset = Sec.offset;
 115   TempSec.align = Sec.align;
 116   TempSec.reloff = Sec.reloff;
 117   TempSec.nreloc = Sec.nreloc;
 118   TempSec.flags = Sec.flags;
 119   TempSec.reserved1 = Sec.reserved1;
 120   TempSec.reserved2 = Sec.reserved2;
 121   return TempSec;
 122 }
 123
 124 template <typename StructType>
 125 size_t writeLoadCommandData(MachOYAML::LoadCommand &LC, raw_ostream &OS,
 126                             bool IsLittleEndian) {
 127   return 0;
 128 }
 129
 130 template <>
 131 size_t writeLoadCommandData<MachO::segment_command>(MachOYAML::LoadCommand &LC,
 132                                                     raw_ostream &OS,
 133                                                     bool IsLittleEndian) {
 134   size_t BytesWritten = 0;
 135   for (const auto &Sec : LC.Sections) {
 136     auto TempSec = constructSection<MachO::section>(Sec);
 137     if (IsLittleEndian != sys::IsLittleEndianHost)
 138       MachO::swapStruct(TempSec);
 139     OS.write(reinterpret_cast<const char *>(&(TempSec)),
 140              sizeof(MachO::section));
 141     BytesWritten += sizeof(MachO::section);
 142   }
 143   return BytesWritten;
 144 }
 145
 146 template <>
 147 size_t writeLoadCommandData<MachO::segment_command_64>(
 148     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 149   size_t BytesWritten = 0;
 150   for (const auto &Sec : LC.Sections) {
 151     auto TempSec = constructSection<MachO::section_64>(Sec);
 152     TempSec.reserved3 = Sec.reserved3;
 153     if (IsLittleEndian != sys::IsLittleEndianHost)
 154       MachO::swapStruct(TempSec);
 155     OS.write(reinterpret_cast<const char *>(&(TempSec)),
 156              sizeof(MachO::section_64));
 157     BytesWritten += sizeof(MachO::section_64);
 158   }
 159   return BytesWritten;
 160 }
 161
 162 size_t writePayloadString(MachOYAML::LoadCommand &LC, raw_ostream &OS) {
 163   size_t BytesWritten = 0;
 164   if (!LC.Content.empty()) {
 165     OS.write(LC.Content.c_str(), LC.Content.length());
 166     BytesWritten = LC.Content.length();
 167   }
 168   return BytesWritten;
 169 }
 170
 171 template <>
 172 size_t writeLoadCommandData<MachO::dylib_command>(MachOYAML::LoadCommand &LC,
 173                                                   raw_ostream &OS,
 174                                                   bool IsLittleEndian) {
 175   return writePayloadString(LC, OS);
 176 }
 177
 178 template <>
 179 size_t writeLoadCommandData<MachO::dylinker_command>(MachOYAML::LoadCommand &LC,
 180                                                      raw_ostream &OS,
 181                                                      bool IsLittleEndian) {
 182   return writePayloadString(LC, OS);
 183 }
 184
 185 template <>
 186 size_t writeLoadCommandData<MachO::rpath_command>(MachOYAML::LoadCommand &LC,
 187                                                   raw_ostream &OS,
 188                                                   bool IsLittleEndian) {
 189   return writePayloadString(LC, OS);
 190 }
 191
 192 template <>
 193 size_t writeLoadCommandData<MachO::sub_framework_command>(
 194     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 195   return writePayloadString(LC, OS);
 196 }
 197
 198 template <>
 199 size_t writeLoadCommandData<MachO::sub_umbrella_command>(
 200     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 201   return writePayloadString(LC, OS);
 202 }
 203
 204 template <>
 205 size_t writeLoadCommandData<MachO::sub_client_command>(
 206     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 207   return writePayloadString(LC, OS);
 208 }
 209
 210 template <>
 211 size_t writeLoadCommandData<MachO::sub_library_command>(
 212     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 213   return writePayloadString(LC, OS);
 214 }
 215
 216 template <>
 217 size_t writeLoadCommandData<MachO::build_version_command>(
 218     MachOYAML::LoadCommand &LC, raw_ostream &OS, bool IsLittleEndian) {
 219   size_t BytesWritten = 0;
 220   for (const auto &T : LC.Tools) {
 221     struct MachO::build_tool_version tool = T;
 222     if (IsLittleEndian != sys::IsLittleEndianHost)
 223       MachO::swapStruct(tool);
 224     OS.write(reinterpret_cast<const char *>(&tool),
 225              sizeof(MachO::build_tool_version));
 226     BytesWritten += sizeof(MachO::build_tool_version);
 227   }
 228   return BytesWritten;
 229 }
 230
 231 void ZeroFillBytes(raw_ostream &OS, size_t Size) {
 232   std::vector<uint8_t> FillData(Size, 0);
 233   OS.write(reinterpret_cast<char *>(FillData.data()), Size);
 234 }
 235
 236 void Fill(raw_ostream &OS, size_t Size, uint32_t Data) {
 237   std::vector<uint32_t> FillData((Size / 4) + 1, Data);
 238   OS.write(reinterpret_cast<char *>(FillData.data()), Size);
 239 }
 240
 241 void MachOWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
 242   auto currOffset = OS.tell() - fileStart;
 243   if (currOffset < Offset)
 244     ZeroFillBytes(OS, Offset - currOffset);
 245 }
 246
 247 void MachOWriter::writeLoadCommands(raw_ostream &OS) {
 248   for (auto &LC : Obj.LoadCommands) {
 249     size_t BytesWritten = 0;
 250     llvm::MachO::macho_load_command Data = LC.Data;
 251
 252 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct)                         \
 253   case MachO::LCName:                                                          \
 254     if (Obj.IsLittleEndian != sys::IsLittleEndianHost)                         \
 255       MachO::swapStruct(Data.LCStruct##_data);                                 \
 256     OS.write(reinterpret_cast<const char *>(&(Data.LCStruct##_data)),          \
 257              sizeof(MachO::LCStruct));                                         \
 258     BytesWritten = sizeof(MachO::LCStruct);                                    \
 259     BytesWritten +=                                                            \
 260         writeLoadCommandData<MachO::LCStruct>(LC, OS, Obj.IsLittleEndian);     \
 261     break;
 262
 263     switch (LC.Data.load_command_data.cmd) {
 264     default:
 265       if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
 266         MachO::swapStruct(Data.load_command_data);
 267       OS.write(reinterpret_cast<const char *>(&(Data.load_command_data)),
 268                sizeof(MachO::load_command));
 269       BytesWritten = sizeof(MachO::load_command);
 270       BytesWritten +=
 271           writeLoadCommandData<MachO::load_command>(LC, OS, Obj.IsLittleEndian);
 272       break;
 273 #include "llvm/BinaryFormat/MachO.def"
 274     }
 275
 276     if (LC.PayloadBytes.size() > 0) {
 277       OS.write(reinterpret_cast<const char *>(LC.PayloadBytes.data()),
 278                LC.PayloadBytes.size());
 279       BytesWritten += LC.PayloadBytes.size();
 280     }
 281
 282     if (LC.ZeroPadBytes > 0) {
 283       ZeroFillBytes(OS, LC.ZeroPadBytes);
 284       BytesWritten += LC.ZeroPadBytes;
 285     }
 286
 287     // Fill remaining bytes with 0. This will only get hit in partially
 288     // specified test cases.
 289     auto BytesRemaining = LC.Data.load_command_data.cmdsize - BytesWritten;
 290     if (BytesRemaining > 0) {
 291       ZeroFillBytes(OS, BytesRemaining);
 292     }
 293   }
 294 }
 295
 296 Error MachOWriter::writeSectionData(raw_ostream &OS) {
 297   uint64_t LinkEditOff = 0;
 298   for (auto &LC : Obj.LoadCommands) {
 299     switch (LC.Data.load_command_data.cmd) {
 300     case MachO::LC_SEGMENT:
 301     case MachO::LC_SEGMENT_64:
 302       uint64_t segOff = is64Bit ? LC.Data.segment_command_64_data.fileoff
 303                                 : LC.Data.segment_command_data.fileoff;
 304       if (0 ==
 305           strncmp(&LC.Data.segment_command_data.segname[0], "__LINKEDIT", 16)) {
 306         FoundLinkEditSeg = true;
 307         LinkEditOff = segOff;
 308         if (Obj.RawLinkEditSegment)
 309           continue;
 310         writeLinkEditData(OS);
 311       }
 312       for (auto &Sec : LC.Sections) {
 313         ZeroToOffset(OS, Sec.offset);
 314         // Zero Fill any data between the end of the last thing we wrote and the
 315         // start of this section.
 316         if (OS.tell() - fileStart > Sec.offset && Sec.offset != (uint32_t)0)
 317           return createStringError(
 318               errc::invalid_argument,
 319               llvm::formatv(
 320                   "wrote too much data somewhere, section offsets in "
 321                   "section {0} for segment {1} don't line up: "
 322                   "[cursor={2:x}], [fileStart={3:x}], [sectionOffset={4:x}]",
 323                   Sec.sectname, Sec.segname, OS.tell(), fileStart,
 324                   Sec.offset.value));
 325
 326         StringRef SectName(Sec.sectname,
 327                            strnlen(Sec.sectname, sizeof(Sec.sectname)));
 328         // If the section's content is specified in the 'DWARF' entry, we will
 329         // emit it regardless of the section's segname.
 330         if (Obj.DWARF.getNonEmptySectionNames().count(SectName.substr(2))) {
 331           if (Sec.content)
 332             return createStringError(errc::invalid_argument,
 333                                      "cannot specify section '" + SectName +
 334                                          "' contents in the 'DWARF' entry and "
 335                                          "the 'content' at the same time");
 336           auto EmitFunc = DWARFYAML::getDWARFEmitterByName(SectName.substr(2));
 337           if (Error Err = EmitFunc(OS, Obj.DWARF))
 338             return Err;
 339           continue;
 340         }
 341
 342         // Skip if it's a virtual section.
 343         if (MachO::isVirtualSection(Sec.flags & MachO::SECTION_TYPE))
 344           continue;
 345
 346         if (Sec.content) {
 347           yaml::BinaryRef Content = *Sec.content;
 348           Content.writeAsBinary(OS);
 349           ZeroFillBytes(OS, Sec.size - Content.binary_size());
 350         } else {
 351           // Fill section data with 0xDEADBEEF.
 352           Fill(OS, Sec.size, 0xDEADBEEFu);
 353         }
 354       }
 355       uint64_t segSize = is64Bit ? LC.Data.segment_command_64_data.filesize
 356                                  : LC.Data.segment_command_data.filesize;
 357       ZeroToOffset(OS, segOff + segSize);
 358       break;
 359     }
 360   }
 361
 362   if (Obj.RawLinkEditSegment) {
 363     ZeroToOffset(OS, LinkEditOff);
 364     if (OS.tell() - fileStart > LinkEditOff || !LinkEditOff)
 365       return createStringError(errc::invalid_argument,
 366                                "section offsets don't line up");
 367     Obj.RawLinkEditSegment->writeAsBinary(OS);
 368   }
 369   return Error::success();
 370 }
 371
 372 // The implementation of makeRelocationInfo and makeScatteredRelocationInfo is
 373 // consistent with how libObject parses MachO binary files. For the reference
 374 // see getStruct, getRelocation, getPlainRelocationPCRel,
 375 // getPlainRelocationLength and related methods in MachOObjectFile.cpp
 376 static MachO::any_relocation_info
 377 makeRelocationInfo(const MachOYAML::Relocation &R, bool IsLE) {
 378   assert(!R.is_scattered && "non-scattered relocation expected");
 379   MachO::any_relocation_info MRE;
 380   MRE.r_word0 = R.address;
 381   if (IsLE)
 382     MRE.r_word1 = ((unsigned)R.symbolnum << 0) | ((unsigned)R.is_pcrel << 24) |
 383                   ((unsigned)R.length << 25) | ((unsigned)R.is_extern << 27) |
 384                   ((unsigned)R.type << 28);
 385   else
 386     MRE.r_word1 = ((unsigned)R.symbolnum << 8) | ((unsigned)R.is_pcrel << 7) |
 387                   ((unsigned)R.length << 5) | ((unsigned)R.is_extern << 4) |
 388                   ((unsigned)R.type << 0);
 389   return MRE;
 390 }
 391
 392 static MachO::any_relocation_info
 393 makeScatteredRelocationInfo(const MachOYAML::Relocation &R) {
 394   assert(R.is_scattered && "scattered relocation expected");
 395   MachO::any_relocation_info MRE;
 396   MRE.r_word0 = (((unsigned)R.address << 0) | ((unsigned)R.type << 24) |
 397                  ((unsigned)R.length << 28) | ((unsigned)R.is_pcrel << 30) |
 398                  MachO::R_SCATTERED);
 399   MRE.r_word1 = R.value;
 400   return MRE;
 401 }
 402
 403 void MachOWriter::writeRelocations(raw_ostream &OS) {
 404   for (const MachOYAML::LoadCommand &LC : Obj.LoadCommands) {
 405     switch (LC.Data.load_command_data.cmd) {
 406     case MachO::LC_SEGMENT:
 407     case MachO::LC_SEGMENT_64:
 408       for (const MachOYAML::Section &Sec : LC.Sections) {
 409         if (Sec.relocations.empty())
 410           continue;
 411         ZeroToOffset(OS, Sec.reloff);
 412         for (const MachOYAML::Relocation &R : Sec.relocations) {
 413           MachO::any_relocation_info MRE =
 414               R.is_scattered ? makeScatteredRelocationInfo(R)
 415                              : makeRelocationInfo(R, Obj.IsLittleEndian);
 416           if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
 417             MachO::swapStruct(MRE);
 418           OS.write(reinterpret_cast<const char *>(&MRE),
 419                    sizeof(MachO::any_relocation_info));
 420         }
 421       }
 422     }
 423   }
 424 }
 425
 426 void MachOWriter::writeBindOpcodes(
 427     raw_ostream &OS, std::vector<MachOYAML::BindOpcode> &BindOpcodes) {
 428
 429   for (auto &Opcode : BindOpcodes) {
 430     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
 431     OS.write(reinterpret_cast<char *>(&OpByte), 1);
 432     for (auto Data : Opcode.ULEBExtraData) {
 433       encodeULEB128(Data, OS);
 434     }
 435     for (auto Data : Opcode.SLEBExtraData) {
 436       encodeSLEB128(Data, OS);
 437     }
 438     if (!Opcode.Symbol.empty()) {
 439       OS.write(Opcode.Symbol.data(), Opcode.Symbol.size());
 440       OS.write('\0');
 441     }
 442   }
 443 }
 444
 445 void MachOWriter::dumpExportEntry(raw_ostream &OS,
 446                                   MachOYAML::ExportEntry &Entry) {
 447   encodeULEB128(Entry.TerminalSize, OS);
 448   if (Entry.TerminalSize > 0) {
 449     encodeULEB128(Entry.Flags, OS);
 450     if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
 451       encodeULEB128(Entry.Other, OS);
 452       OS << Entry.ImportName;
 453       OS.write('\0');
 454     } else {
 455       encodeULEB128(Entry.Address, OS);
 456       if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
 457         encodeULEB128(Entry.Other, OS);
 458     }
 459   }
 460   OS.write(static_cast<uint8_t>(Entry.Children.size()));
 461   for (auto EE : Entry.Children) {
 462     OS << EE.Name;
 463     OS.write('\0');
 464     encodeULEB128(EE.NodeOffset, OS);
 465   }
 466   for (auto EE : Entry.Children)
 467     dumpExportEntry(OS, EE);
 468 }
 469
 470 void MachOWriter::writeExportTrie(raw_ostream &OS) {
 471   dumpExportEntry(OS, Obj.LinkEdit.ExportTrie);
 472 }
 473
 474 template <typename NListType>
 475 void writeNListEntry(MachOYAML::NListEntry &NLE, raw_ostream &OS,
 476                      bool IsLittleEndian) {
 477   NListType ListEntry;
 478   ListEntry.n_strx = NLE.n_strx;
 479   ListEntry.n_type = NLE.n_type;
 480   ListEntry.n_sect = NLE.n_sect;
 481   ListEntry.n_desc = NLE.n_desc;
 482   ListEntry.n_value = NLE.n_value;
 483
 484   if (IsLittleEndian != sys::IsLittleEndianHost)
 485     MachO::swapStruct(ListEntry);
 486   OS.write(reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
 487 }
 488
 489 void MachOWriter::writeLinkEditData(raw_ostream &OS) {
 490   typedef void (MachOWriter::*writeHandler)(raw_ostream &);
 491   typedef std::pair<uint64_t, writeHandler> writeOperation;
 492   std::vector<writeOperation> WriteQueue;
 493
 494   MachO::dyld_info_command *DyldInfoOnlyCmd = nullptr;
 495   MachO::symtab_command *SymtabCmd = nullptr;
 496   MachO::dysymtab_command *DSymtabCmd = nullptr;
 497   MachO::linkedit_data_command *FunctionStartsCmd = nullptr;
 498   MachO::linkedit_data_command *ChainedFixupsCmd = nullptr;
 499   MachO::linkedit_data_command *DyldExportsTrieCmd = nullptr;
 500   MachO::linkedit_data_command *DataInCodeCmd = nullptr;
 501   for (auto &LC : Obj.LoadCommands) {
 502     switch (LC.Data.load_command_data.cmd) {
 503     case MachO::LC_SYMTAB:
 504       SymtabCmd = &LC.Data.symtab_command_data;
 505       WriteQueue.push_back(
 506           std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList));
 507       WriteQueue.push_back(
 508           std::make_pair(SymtabCmd->stroff, &MachOWriter::writeStringTable));
 509       break;
 510     case MachO::LC_DYLD_INFO_ONLY:
 511       DyldInfoOnlyCmd = &LC.Data.dyld_info_command_data;
 512       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->rebase_off,
 513                                           &MachOWriter::writeRebaseOpcodes));
 514       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->bind_off,
 515                                           &MachOWriter::writeBasicBindOpcodes));
 516       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off,
 517                                           &MachOWriter::writeWeakBindOpcodes));
 518       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off,
 519                                           &MachOWriter::writeLazyBindOpcodes));
 520       WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off,
 521                                           &MachOWriter::writeExportTrie));
 522       break;
 523     case MachO::LC_DYSYMTAB:
 524       DSymtabCmd = &LC.Data.dysymtab_command_data;
 525       WriteQueue.push_back(std::make_pair(
 526           DSymtabCmd->indirectsymoff, &MachOWriter::writeDynamicSymbolTable));
 527       break;
 528     case MachO::LC_FUNCTION_STARTS:
 529       FunctionStartsCmd = &LC.Data.linkedit_data_command_data;
 530       WriteQueue.push_back(std::make_pair(FunctionStartsCmd->dataoff,
 531                                           &MachOWriter::writeFunctionStarts));
 532       break;
 533     case MachO::LC_DYLD_CHAINED_FIXUPS:
 534       ChainedFixupsCmd = &LC.Data.linkedit_data_command_data;
 535       WriteQueue.push_back(std::make_pair(ChainedFixupsCmd->dataoff,
 536                                           &MachOWriter::writeChainedFixups));
 537       break;
 538     case MachO::LC_DYLD_EXPORTS_TRIE:
 539       DyldExportsTrieCmd = &LC.Data.linkedit_data_command_data;
 540       WriteQueue.push_back(std::make_pair(DyldExportsTrieCmd->dataoff,
 541                                           &MachOWriter::writeDyldExportsTrie));
 542       break;
 543     case MachO::LC_DATA_IN_CODE:
 544       DataInCodeCmd = &LC.Data.linkedit_data_command_data;
 545       WriteQueue.push_back(std::make_pair(DataInCodeCmd->dataoff,
 546                                           &MachOWriter::writeDataInCode));
 547       break;
 548     }
 549   }
 550
 551   llvm::sort(WriteQueue, llvm::less_first());
 552
 553   for (auto writeOp : WriteQueue) {
 554     ZeroToOffset(OS, writeOp.first);
 555     (this->*writeOp.second)(OS);
 556   }
 557 }
 558
 559 void MachOWriter::writeRebaseOpcodes(raw_ostream &OS) {
 560   MachOYAML::LinkEditData &LinkEdit = Obj.LinkEdit;
 561
 562   for (auto Opcode : LinkEdit.RebaseOpcodes) {
 563     uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
 564     OS.write(reinterpret_cast<char *>(&OpByte), 1);
 565     for (auto Data : Opcode.ExtraData)
 566       encodeULEB128(Data, OS);
 567   }
 568 }
 569
 570 void MachOWriter::writeBasicBindOpcodes(raw_ostream &OS) {
 571   writeBindOpcodes(OS, Obj.LinkEdit.BindOpcodes);
 572 }
 573
 574 void MachOWriter::writeWeakBindOpcodes(raw_ostream &OS) {
 575   writeBindOpcodes(OS, Obj.LinkEdit.WeakBindOpcodes);
 576 }
 577
 578 void MachOWriter::writeLazyBindOpcodes(raw_ostream &OS) {
 579   writeBindOpcodes(OS, Obj.LinkEdit.LazyBindOpcodes);
 580 }
 581
 582 void MachOWriter::writeNameList(raw_ostream &OS) {
 583   for (auto NLE : Obj.LinkEdit.NameList) {
 584     if (is64Bit)
 585       writeNListEntry<MachO::nlist_64>(NLE, OS, Obj.IsLittleEndian);
 586     else
 587       writeNListEntry<MachO::nlist>(NLE, OS, Obj.IsLittleEndian);
 588   }
 589 }
 590
 591 void MachOWriter::writeStringTable(raw_ostream &OS) {
 592   for (auto Str : Obj.LinkEdit.StringTable) {
 593     OS.write(Str.data(), Str.size());
 594     OS.write('\0');
 595   }
 596 }
 597
 598 void MachOWriter::writeDynamicSymbolTable(raw_ostream &OS) {
 599   for (auto Data : Obj.LinkEdit.IndirectSymbols)
 600     OS.write(reinterpret_cast<const char *>(&Data),
 601              sizeof(yaml::Hex32::BaseType));
 602 }
 603
 604 void MachOWriter::writeFunctionStarts(raw_ostream &OS) {
 605   uint64_t Addr = 0;
 606   for (uint64_t NextAddr : Obj.LinkEdit.FunctionStarts) {
 607     uint64_t Delta = NextAddr - Addr;
 608     encodeULEB128(Delta, OS);
 609     Addr = NextAddr;
 610   }
 611
 612   OS.write('\0');
 613 }
 614
 615 void MachOWriter::writeDataInCode(raw_ostream &OS) {
 616   for (const auto &Entry : Obj.LinkEdit.DataInCode) {
 617     MachO::data_in_code_entry DICE{Entry.Offset, Entry.Length, Entry.Kind};
 618     if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
 619       MachO::swapStruct(DICE);
 620     OS.write(reinterpret_cast<const char *>(&DICE),
 621              sizeof(MachO::data_in_code_entry));
 622   }
 623 }
 624
 625 void MachOWriter::writeChainedFixups(raw_ostream &OS) {
 626   if (Obj.LinkEdit.ChainedFixups.size() > 0)
 627     OS.write(reinterpret_cast<const char *>(Obj.LinkEdit.ChainedFixups.data()),
 628              Obj.LinkEdit.ChainedFixups.size());
 629 }
 630
 631 void MachOWriter::writeDyldExportsTrie(raw_ostream &OS) {
 632   dumpExportEntry(OS, Obj.LinkEdit.ExportTrie);
 633 }
 634
 635 class UniversalWriter {
 636 public:
 637   UniversalWriter(yaml::YamlObjectFile &ObjectFile)
 638       : ObjectFile(ObjectFile), fileStart(0) {}
 639
 640   Error writeMachO(raw_ostream &OS);
 641
 642 private:
 643   void writeFatHeader(raw_ostream &OS);
 644   void writeFatArchs(raw_ostream &OS);
 645
 646   void ZeroToOffset(raw_ostream &OS, size_t offset);
 647
 648   yaml::YamlObjectFile &ObjectFile;
 649   uint64_t fileStart;
 650 };
 651
 652 Error UniversalWriter::writeMachO(raw_ostream &OS) {
 653   fileStart = OS.tell();
 654   if (ObjectFile.MachO) {
 655     MachOWriter Writer(*ObjectFile.MachO);
 656     return Writer.writeMachO(OS);
 657   }
 658
 659   writeFatHeader(OS);
 660   writeFatArchs(OS);
 661
 662   auto &FatFile = *ObjectFile.FatMachO;
 663   if (FatFile.FatArchs.size() < FatFile.Slices.size())
 664     return createStringError(
 665         errc::invalid_argument,
 666         "cannot write 'Slices' if not described in 'FatArches'");
 667
 668   for (size_t i = 0; i < FatFile.Slices.size(); i++) {
 669     ZeroToOffset(OS, FatFile.FatArchs[i].offset);
 670     MachOWriter Writer(FatFile.Slices[i]);
 671     if (Error Err = Writer.writeMachO(OS))
 672       return Err;
 673
 674     auto SliceEnd = FatFile.FatArchs[i].offset + FatFile.FatArchs[i].size;
 675     ZeroToOffset(OS, SliceEnd);
 676   }
 677
 678   return Error::success();
 679 }
 680
 681 void UniversalWriter::writeFatHeader(raw_ostream &OS) {
 682   auto &FatFile = *ObjectFile.FatMachO;
 683   MachO::fat_header header;
 684   header.magic = FatFile.Header.magic;
 685   header.nfat_arch = FatFile.Header.nfat_arch;
 686   if (sys::IsLittleEndianHost)
 687     swapStruct(header);
 688   OS.write(reinterpret_cast<const char *>(&header), sizeof(MachO::fat_header));
 689 }
 690
 691 template <typename FatArchType>
 692 FatArchType constructFatArch(MachOYAML::FatArch &Arch) {
 693   FatArchType FatArch;
 694   FatArch.cputype = Arch.cputype;
 695   FatArch.cpusubtype = Arch.cpusubtype;
 696   FatArch.offset = Arch.offset;
 697   FatArch.size = Arch.size;
 698   FatArch.align = Arch.align;
 699   return FatArch;
 700 }
 701
 702 template <typename StructType>
 703 void writeFatArch(MachOYAML::FatArch &LC, raw_ostream &OS) {}
 704
 705 template <>
 706 void writeFatArch<MachO::fat_arch>(MachOYAML::FatArch &Arch, raw_ostream &OS) {
 707   auto FatArch = constructFatArch<MachO::fat_arch>(Arch);
 708   if (sys::IsLittleEndianHost)
 709     swapStruct(FatArch);
 710   OS.write(reinterpret_cast<const char *>(&FatArch), sizeof(MachO::fat_arch));
 711 }
 712
 713 template <>
 714 void writeFatArch<MachO::fat_arch_64>(MachOYAML::FatArch &Arch,
 715                                       raw_ostream &OS) {
 716   auto FatArch = constructFatArch<MachO::fat_arch_64>(Arch);
 717   FatArch.reserved = Arch.reserved;
 718   if (sys::IsLittleEndianHost)
 719     swapStruct(FatArch);
 720   OS.write(reinterpret_cast<const char *>(&FatArch),
 721            sizeof(MachO::fat_arch_64));
 722 }
 723
 724 void UniversalWriter::writeFatArchs(raw_ostream &OS) {
 725   auto &FatFile = *ObjectFile.FatMachO;
 726   bool is64Bit = FatFile.Header.magic == MachO::FAT_MAGIC_64;
 727   for (auto Arch : FatFile.FatArchs) {
 728     if (is64Bit)
 729       writeFatArch<MachO::fat_arch_64>(Arch, OS);
 730     else
 731       writeFatArch<MachO::fat_arch>(Arch, OS);
 732   }
 733 }
 734
 735 void UniversalWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
 736   auto currOffset = OS.tell() - fileStart;
 737   if (currOffset < Offset)
 738     ZeroFillBytes(OS, Offset - currOffset);
 739 }
 740
 741 } // end anonymous namespace
 742
 743 namespace llvm {
 744 namespace yaml {
 745
 746 bool yaml2macho(YamlObjectFile &Doc, raw_ostream &Out, ErrorHandler EH) {
 747   UniversalWriter Writer(Doc);
 748   if (Error Err = Writer.writeMachO(Out)) {
 749     handleAllErrors(std::move(Err),
 750                     [&](const ErrorInfoBase &Err) { EH(Err.message()); });
 751     return false;
 752   }
 753   return true;
 754 }
 755
 756 } // namespace yaml
 757 } // namespace llvm