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