1 //===- yaml2macho - Convert YAML to a Mach object file --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief The Mach component of yaml2obj.
13 //===----------------------------------------------------------------------===//
16 #include "llvm/ObjectYAML/ObjectYAML.h"
17 #include "llvm/Support/Error.h"
18 #include "llvm/Support/LEB128.h"
19 #include "llvm/Support/MachO.h"
20 #include "llvm/Support/YAMLTraits.h"
21 #include "llvm/Support/raw_ostream.h"
23 #include "llvm/Support/Format.h"
31 MachOWriter(MachOYAML::Object &Obj) : Obj(Obj), is64Bit(true), fileStart(0) {
32 is64Bit = Obj.Header.magic == MachO::MH_MAGIC_64 ||
33 Obj.Header.magic == MachO::MH_CIGAM_64;
34 memset(reinterpret_cast<void *>(&Header), 0, sizeof(MachO::mach_header_64));
37 Error writeMachO(raw_ostream &OS);
40 Error writeHeader(raw_ostream &OS);
41 Error writeLoadCommands(raw_ostream &OS);
42 Error writeSectionData(raw_ostream &OS);
43 Error writeLinkEditData(raw_ostream &OS);
45 void writeBindOpcodes(raw_ostream &OS,
46 std::vector<MachOYAML::BindOpcode> &BindOpcodes);
48 Error writeRebaseOpcodes(raw_ostream &OS);
49 Error writeBasicBindOpcodes(raw_ostream &OS);
50 Error writeWeakBindOpcodes(raw_ostream &OS);
51 Error writeLazyBindOpcodes(raw_ostream &OS);
52 Error writeNameList(raw_ostream &OS);
53 Error writeStringTable(raw_ostream &OS);
54 Error writeExportTrie(raw_ostream &OS);
56 void dumpExportEntry(raw_ostream &OS, MachOYAML::ExportEntry &Entry);
57 void ZeroToOffset(raw_ostream &OS, size_t offset);
59 MachOYAML::Object &Obj;
63 MachO::mach_header_64 Header;
66 Error MachOWriter::writeMachO(raw_ostream &OS) {
67 fileStart = OS.tell();
68 if (auto Err = writeHeader(OS))
70 if (auto Err = writeLoadCommands(OS))
72 if (auto Err = writeSectionData(OS))
74 return Error::success();
77 Error MachOWriter::writeHeader(raw_ostream &OS) {
78 Header.magic = Obj.Header.magic;
79 Header.cputype = Obj.Header.cputype;
80 Header.cpusubtype = Obj.Header.cpusubtype;
81 Header.filetype = Obj.Header.filetype;
82 Header.ncmds = Obj.Header.ncmds;
83 Header.sizeofcmds = Obj.Header.sizeofcmds;
84 Header.flags = Obj.Header.flags;
85 Header.reserved = Obj.Header.reserved;
87 if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
88 MachO::swapStruct(Header);
91 is64Bit ? sizeof(MachO::mach_header_64) : sizeof(MachO::mach_header);
92 OS.write((const char *)&Header, header_size);
94 return Error::success();
97 template <typename SectionType>
98 SectionType constructSection(MachOYAML::Section Sec) {
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;
114 template <typename StructType>
115 size_t writeLoadCommandData(MachOYAML::LoadCommand &LC, raw_ostream &OS,
116 bool IsLittleEndian) {
121 size_t writeLoadCommandData<MachO::segment_command>(MachOYAML::LoadCommand &LC,
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);
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);
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();
162 size_t writeLoadCommandData<MachO::dylib_command>(MachOYAML::LoadCommand &LC,
164 bool IsLittleEndian) {
165 return writePayloadString(LC, OS);
169 size_t writeLoadCommandData<MachO::dylinker_command>(MachOYAML::LoadCommand &LC,
171 bool IsLittleEndian) {
172 return writePayloadString(LC, OS);
176 size_t writeLoadCommandData<MachO::rpath_command>(MachOYAML::LoadCommand &LC,
178 bool IsLittleEndian) {
179 return writePayloadString(LC, OS);
182 void ZeroFillBytes(raw_ostream &OS, size_t Size) {
183 std::vector<uint8_t> FillData;
184 FillData.insert(FillData.begin(), Size, 0);
185 OS.write(reinterpret_cast<char *>(FillData.data()), Size);
188 void Fill(raw_ostream &OS, size_t Size, uint32_t Data) {
189 std::vector<uint32_t> FillData;
190 FillData.insert(FillData.begin(), (Size / 4) + 1, Data);
191 OS.write(reinterpret_cast<char *>(FillData.data()), Size);
194 void MachOWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
195 auto currOffset = OS.tell() - fileStart;
196 if (currOffset < Offset)
197 ZeroFillBytes(OS, Offset - currOffset);
200 Error MachOWriter::writeLoadCommands(raw_ostream &OS) {
201 for (auto &LC : Obj.LoadCommands) {
202 size_t BytesWritten = 0;
203 llvm::MachO::macho_load_command Data = LC.Data;
205 #define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
206 case MachO::LCName: \
207 if (Obj.IsLittleEndian != sys::IsLittleEndianHost) \
208 MachO::swapStruct(Data.LCStruct##_data); \
209 OS.write(reinterpret_cast<const char *>(&(Data.LCStruct##_data)), \
210 sizeof(MachO::LCStruct)); \
211 BytesWritten = sizeof(MachO::LCStruct); \
213 writeLoadCommandData<MachO::LCStruct>(LC, OS, Obj.IsLittleEndian); \
216 switch (LC.Data.load_command_data.cmd) {
218 if (Obj.IsLittleEndian != sys::IsLittleEndianHost)
219 MachO::swapStruct(Data.load_command_data);
220 OS.write(reinterpret_cast<const char *>(&(Data.load_command_data)),
221 sizeof(MachO::load_command));
222 BytesWritten = sizeof(MachO::load_command);
224 writeLoadCommandData<MachO::load_command>(LC, OS, Obj.IsLittleEndian);
226 #include "llvm/Support/MachO.def"
229 if (LC.PayloadBytes.size() > 0) {
230 OS.write(reinterpret_cast<const char *>(LC.PayloadBytes.data()),
231 LC.PayloadBytes.size());
232 BytesWritten += LC.PayloadBytes.size();
235 if (LC.ZeroPadBytes > 0) {
236 ZeroFillBytes(OS, LC.ZeroPadBytes);
237 BytesWritten += LC.ZeroPadBytes;
240 // Fill remaining bytes with 0. This will only get hit in partially
241 // specified test cases.
242 auto BytesRemaining = LC.Data.load_command_data.cmdsize - BytesWritten;
243 if (BytesRemaining > 0) {
244 ZeroFillBytes(OS, BytesRemaining);
247 return Error::success();
250 Error MachOWriter::writeSectionData(raw_ostream &OS) {
251 bool FoundLinkEditSeg = false;
252 for (auto &LC : Obj.LoadCommands) {
253 switch (LC.Data.load_command_data.cmd) {
254 case MachO::LC_SEGMENT:
255 case MachO::LC_SEGMENT_64:
256 uint64_t segOff = is64Bit ? LC.Data.segment_command_64_data.fileoff
257 : LC.Data.segment_command_data.fileoff;
258 if (0 == strncmp(&LC.Data.segment_command_data.segname[0], "__LINKEDIT", 16)) {
259 FoundLinkEditSeg = true;
260 if (auto Err = writeLinkEditData(OS))
263 for (auto &Sec : LC.Sections) {
264 ZeroToOffset(OS, Sec.offset);
265 // Zero Fill any data between the end of the last thing we wrote and the
266 // start of this section.
267 assert((OS.tell() - fileStart <= Sec.offset ||
268 Sec.offset == (uint32_t)0) &&
269 "Wrote too much data somewhere, section offsets don't line up.");
270 if (0 == strncmp(&Sec.segname[0], "__DWARF", 16)) {
271 if (0 == strncmp(&Sec.sectname[0], "__debug_str", 16)) {
272 yaml2debug_str(OS, Obj.DWARF);
273 } else if (0 == strncmp(&Sec.sectname[0], "__debug_abbrev", 16)) {
274 yaml2debug_abbrev(OS, Obj.DWARF);
275 } else if (0 == strncmp(&Sec.sectname[0], "__debug_aranges", 16)) {
276 yaml2debug_aranges(OS, Obj.DWARF);
277 } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubnames", 16)) {
278 yaml2pubsection(OS, Obj.DWARF.PubNames, Obj.IsLittleEndian);
279 } else if (0 == strncmp(&Sec.sectname[0], "__debug_pubtypes", 16)) {
280 yaml2pubsection(OS, Obj.DWARF.PubTypes, Obj.IsLittleEndian);
281 } else if (0 == strncmp(&Sec.sectname[0], "__debug_info", 16)) {
282 yaml2debug_info(OS, Obj.DWARF);
285 // Fills section data with 0xDEADBEEF
286 Fill(OS, Sec.size, 0xDEADBEEFu);
289 uint64_t segSize = is64Bit ? LC.Data.segment_command_64_data.filesize
290 : LC.Data.segment_command_data.filesize;
291 ZeroToOffset(OS, segOff + segSize);
295 // Old PPC Object Files didn't have __LINKEDIT segments, the data was just
296 // stuck at the end of the file.
297 if (!FoundLinkEditSeg) {
298 if (auto Err = writeLinkEditData(OS))
301 return Error::success();
304 void MachOWriter::writeBindOpcodes(
305 raw_ostream &OS, std::vector<MachOYAML::BindOpcode> &BindOpcodes) {
307 for (auto Opcode : BindOpcodes) {
308 uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
309 OS.write(reinterpret_cast<char *>(&OpByte), 1);
310 for (auto Data : Opcode.ULEBExtraData) {
311 encodeULEB128(Data, OS);
313 for (auto Data : Opcode.SLEBExtraData) {
314 encodeSLEB128(Data, OS);
316 if (!Opcode.Symbol.empty()) {
317 OS.write(Opcode.Symbol.data(), Opcode.Symbol.size());
323 void MachOWriter::dumpExportEntry(raw_ostream &OS,
324 MachOYAML::ExportEntry &Entry) {
325 encodeSLEB128(Entry.TerminalSize, OS);
326 if (Entry.TerminalSize > 0) {
327 encodeSLEB128(Entry.Flags, OS);
328 if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_REEXPORT) {
329 encodeSLEB128(Entry.Other, OS);
330 OS << Entry.ImportName;
333 encodeSLEB128(Entry.Address, OS);
334 if (Entry.Flags & MachO::EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
335 encodeSLEB128(Entry.Other, OS);
338 OS.write(static_cast<uint8_t>(Entry.Children.size()));
339 for (auto EE : Entry.Children) {
342 encodeSLEB128(EE.NodeOffset, OS);
344 for (auto EE : Entry.Children)
345 dumpExportEntry(OS, EE);
348 Error MachOWriter::writeExportTrie(raw_ostream &OS) {
349 dumpExportEntry(OS, Obj.LinkEdit.ExportTrie);
350 return Error::success();
353 template <typename NListType>
354 void writeNListEntry(MachOYAML::NListEntry &NLE, raw_ostream &OS,
355 bool IsLittleEndian) {
357 ListEntry.n_strx = NLE.n_strx;
358 ListEntry.n_type = NLE.n_type;
359 ListEntry.n_sect = NLE.n_sect;
360 ListEntry.n_desc = NLE.n_desc;
361 ListEntry.n_value = NLE.n_value;
363 if (IsLittleEndian != sys::IsLittleEndianHost)
364 MachO::swapStruct(ListEntry);
365 OS.write(reinterpret_cast<const char *>(&ListEntry), sizeof(NListType));
368 Error MachOWriter::writeLinkEditData(raw_ostream &OS) {
369 typedef Error (MachOWriter::*writeHandler)(raw_ostream &);
370 typedef std::pair<uint64_t, writeHandler> writeOperation;
371 std::vector<writeOperation> WriteQueue;
373 MachO::dyld_info_command *DyldInfoOnlyCmd = 0;
374 MachO::symtab_command *SymtabCmd = 0;
375 for (auto &LC : Obj.LoadCommands) {
376 switch (LC.Data.load_command_data.cmd) {
377 case MachO::LC_SYMTAB:
378 SymtabCmd = &LC.Data.symtab_command_data;
379 WriteQueue.push_back(
380 std::make_pair(SymtabCmd->symoff, &MachOWriter::writeNameList));
381 WriteQueue.push_back(
382 std::make_pair(SymtabCmd->stroff, &MachOWriter::writeStringTable));
384 case MachO::LC_DYLD_INFO_ONLY:
385 DyldInfoOnlyCmd = &LC.Data.dyld_info_command_data;
386 WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->rebase_off,
387 &MachOWriter::writeRebaseOpcodes));
388 WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->bind_off,
389 &MachOWriter::writeBasicBindOpcodes));
390 WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->weak_bind_off,
391 &MachOWriter::writeWeakBindOpcodes));
392 WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->lazy_bind_off,
393 &MachOWriter::writeLazyBindOpcodes));
394 WriteQueue.push_back(std::make_pair(DyldInfoOnlyCmd->export_off,
395 &MachOWriter::writeExportTrie));
400 std::sort(WriteQueue.begin(), WriteQueue.end(),
401 [](const writeOperation &a, const writeOperation &b) {
402 return a.first < b.first;
405 for (auto writeOp : WriteQueue) {
406 ZeroToOffset(OS, writeOp.first);
407 if (auto Err = (this->*writeOp.second)(OS))
411 return Error::success();
414 Error MachOWriter::writeRebaseOpcodes(raw_ostream &OS) {
415 MachOYAML::LinkEditData &LinkEdit = Obj.LinkEdit;
417 for (auto Opcode : LinkEdit.RebaseOpcodes) {
418 uint8_t OpByte = Opcode.Opcode | Opcode.Imm;
419 OS.write(reinterpret_cast<char *>(&OpByte), 1);
420 for (auto Data : Opcode.ExtraData) {
421 encodeULEB128(Data, OS);
424 return Error::success();
427 Error MachOWriter::writeBasicBindOpcodes(raw_ostream &OS) {
428 writeBindOpcodes(OS, Obj.LinkEdit.BindOpcodes);
429 return Error::success();
432 Error MachOWriter::writeWeakBindOpcodes(raw_ostream &OS) {
433 writeBindOpcodes(OS, Obj.LinkEdit.WeakBindOpcodes);
434 return Error::success();
437 Error MachOWriter::writeLazyBindOpcodes(raw_ostream &OS) {
438 writeBindOpcodes(OS, Obj.LinkEdit.LazyBindOpcodes);
439 return Error::success();
442 Error MachOWriter::writeNameList(raw_ostream &OS) {
443 for (auto NLE : Obj.LinkEdit.NameList) {
445 writeNListEntry<MachO::nlist_64>(NLE, OS, Obj.IsLittleEndian);
447 writeNListEntry<MachO::nlist>(NLE, OS, Obj.IsLittleEndian);
449 return Error::success();
452 Error MachOWriter::writeStringTable(raw_ostream &OS) {
453 for (auto Str : Obj.LinkEdit.StringTable) {
454 OS.write(Str.data(), Str.size());
457 return Error::success();
460 class UniversalWriter {
462 UniversalWriter(yaml::YamlObjectFile &ObjectFile)
463 : ObjectFile(ObjectFile), fileStart(0) {}
465 Error writeMachO(raw_ostream &OS);
468 Error writeFatHeader(raw_ostream &OS);
469 Error writeFatArchs(raw_ostream &OS);
471 void ZeroToOffset(raw_ostream &OS, size_t offset);
473 yaml::YamlObjectFile &ObjectFile;
477 Error UniversalWriter::writeMachO(raw_ostream &OS) {
478 fileStart = OS.tell();
479 if (ObjectFile.MachO) {
480 MachOWriter Writer(*ObjectFile.MachO);
481 return Writer.writeMachO(OS);
483 if (auto Err = writeFatHeader(OS))
485 if (auto Err = writeFatArchs(OS))
487 auto &FatFile = *ObjectFile.FatMachO;
488 assert(FatFile.FatArchs.size() == FatFile.Slices.size());
489 for (size_t i = 0; i < FatFile.Slices.size(); i++) {
490 ZeroToOffset(OS, FatFile.FatArchs[i].offset);
491 MachOWriter Writer(FatFile.Slices[i]);
492 if (auto Err = Writer.writeMachO(OS))
494 auto SliceEnd = FatFile.FatArchs[i].offset + FatFile.FatArchs[i].size;
495 ZeroToOffset(OS, SliceEnd);
497 return Error::success();
500 Error UniversalWriter::writeFatHeader(raw_ostream &OS) {
501 auto &FatFile = *ObjectFile.FatMachO;
502 MachO::fat_header header;
503 header.magic = FatFile.Header.magic;
504 header.nfat_arch = FatFile.Header.nfat_arch;
505 if (sys::IsLittleEndianHost)
507 OS.write(reinterpret_cast<const char *>(&header), sizeof(MachO::fat_header));
508 return Error::success();
511 template <typename FatArchType>
512 FatArchType constructFatArch(MachOYAML::FatArch &Arch) {
514 FatArch.cputype = Arch.cputype;
515 FatArch.cpusubtype = Arch.cpusubtype;
516 FatArch.offset = Arch.offset;
517 FatArch.size = Arch.size;
518 FatArch.align = Arch.align;
522 template <typename StructType>
523 void writeFatArch(MachOYAML::FatArch &LC, raw_ostream &OS) {}
526 void writeFatArch<MachO::fat_arch>(MachOYAML::FatArch &Arch, raw_ostream &OS) {
527 auto FatArch = constructFatArch<MachO::fat_arch>(Arch);
528 if (sys::IsLittleEndianHost)
530 OS.write(reinterpret_cast<const char *>(&FatArch), sizeof(MachO::fat_arch));
534 void writeFatArch<MachO::fat_arch_64>(MachOYAML::FatArch &Arch,
536 auto FatArch = constructFatArch<MachO::fat_arch_64>(Arch);
537 FatArch.reserved = Arch.reserved;
538 if (sys::IsLittleEndianHost)
540 OS.write(reinterpret_cast<const char *>(&FatArch),
541 sizeof(MachO::fat_arch_64));
544 Error UniversalWriter::writeFatArchs(raw_ostream &OS) {
545 auto &FatFile = *ObjectFile.FatMachO;
546 bool is64Bit = FatFile.Header.magic == MachO::FAT_MAGIC_64;
547 for (auto Arch : FatFile.FatArchs) {
549 writeFatArch<MachO::fat_arch_64>(Arch, OS);
551 writeFatArch<MachO::fat_arch>(Arch, OS);
554 return Error::success();
557 void UniversalWriter::ZeroToOffset(raw_ostream &OS, size_t Offset) {
558 auto currOffset = OS.tell() - fileStart;
559 if (currOffset < Offset)
560 ZeroFillBytes(OS, Offset - currOffset);
563 } // end anonymous namespace
565 int yaml2macho(yaml::YamlObjectFile &Doc, raw_ostream &Out) {
566 UniversalWriter Writer(Doc);
567 if (auto Err = Writer.writeMachO(Out)) {
568 errs() << toString(std::move(Err));