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