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