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