1 //===- Writer.cpp ---------------------------------------------------------===// 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 #include "Writer.h" 10 #include "ConcatOutputSection.h" 11 #include "Config.h" 12 #include "InputFiles.h" 13 #include "InputSection.h" 14 #include "MapFile.h" 15 #include "OutputSection.h" 16 #include "OutputSegment.h" 17 #include "SectionPriorities.h" 18 #include "SymbolTable.h" 19 #include "Symbols.h" 20 #include "SyntheticSections.h" 21 #include "Target.h" 22 #include "UnwindInfoSection.h" 23 24 #include "lld/Common/Arrays.h" 25 #include "lld/Common/CommonLinkerContext.h" 26 #include "llvm/BinaryFormat/MachO.h" 27 #include "llvm/Config/llvm-config.h" 28 #include "llvm/Support/LEB128.h" 29 #include "llvm/Support/Parallel.h" 30 #include "llvm/Support/Path.h" 31 #include "llvm/Support/ThreadPool.h" 32 #include "llvm/Support/TimeProfiler.h" 33 #include "llvm/Support/xxhash.h" 34 35 #include <algorithm> 36 37 using namespace llvm; 38 using namespace llvm::MachO; 39 using namespace llvm::sys; 40 using namespace lld; 41 using namespace lld::macho; 42 43 namespace { 44 class LCUuid; 45 46 class Writer { 47 public: 48 Writer() : buffer(errorHandler().outputBuffer) {} 49 50 void treatSpecialUndefineds(); 51 void scanRelocations(); 52 void scanSymbols(); 53 template <class LP> void createOutputSections(); 54 template <class LP> void createLoadCommands(); 55 void finalizeAddresses(); 56 void finalizeLinkEditSegment(); 57 void assignAddresses(OutputSegment *); 58 59 void openFile(); 60 void writeSections(); 61 void applyOptimizationHints(); 62 void buildFixupChains(); 63 void writeUuid(); 64 void writeCodeSignature(); 65 void writeOutputFile(); 66 67 template <class LP> void run(); 68 69 ThreadPool threadPool; 70 std::unique_ptr<FileOutputBuffer> &buffer; 71 uint64_t addr = 0; 72 uint64_t fileOff = 0; 73 MachHeaderSection *header = nullptr; 74 StringTableSection *stringTableSection = nullptr; 75 SymtabSection *symtabSection = nullptr; 76 IndirectSymtabSection *indirectSymtabSection = nullptr; 77 CodeSignatureSection *codeSignatureSection = nullptr; 78 DataInCodeSection *dataInCodeSection = nullptr; 79 FunctionStartsSection *functionStartsSection = nullptr; 80 81 LCUuid *uuidCommand = nullptr; 82 OutputSegment *linkEditSegment = nullptr; 83 }; 84 85 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information. 86 class LCDyldInfo final : public LoadCommand { 87 public: 88 LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection, 89 WeakBindingSection *weakBindingSection, 90 LazyBindingSection *lazyBindingSection, 91 ExportSection *exportSection) 92 : rebaseSection(rebaseSection), bindingSection(bindingSection), 93 weakBindingSection(weakBindingSection), 94 lazyBindingSection(lazyBindingSection), exportSection(exportSection) {} 95 96 uint32_t getSize() const override { return sizeof(dyld_info_command); } 97 98 void writeTo(uint8_t *buf) const override { 99 auto *c = reinterpret_cast<dyld_info_command *>(buf); 100 c->cmd = LC_DYLD_INFO_ONLY; 101 c->cmdsize = getSize(); 102 if (rebaseSection->isNeeded()) { 103 c->rebase_off = rebaseSection->fileOff; 104 c->rebase_size = rebaseSection->getFileSize(); 105 } 106 if (bindingSection->isNeeded()) { 107 c->bind_off = bindingSection->fileOff; 108 c->bind_size = bindingSection->getFileSize(); 109 } 110 if (weakBindingSection->isNeeded()) { 111 c->weak_bind_off = weakBindingSection->fileOff; 112 c->weak_bind_size = weakBindingSection->getFileSize(); 113 } 114 if (lazyBindingSection->isNeeded()) { 115 c->lazy_bind_off = lazyBindingSection->fileOff; 116 c->lazy_bind_size = lazyBindingSection->getFileSize(); 117 } 118 if (exportSection->isNeeded()) { 119 c->export_off = exportSection->fileOff; 120 c->export_size = exportSection->getFileSize(); 121 } 122 } 123 124 RebaseSection *rebaseSection; 125 BindingSection *bindingSection; 126 WeakBindingSection *weakBindingSection; 127 LazyBindingSection *lazyBindingSection; 128 ExportSection *exportSection; 129 }; 130 131 class LCSubFramework final : public LoadCommand { 132 public: 133 LCSubFramework(StringRef umbrella) : umbrella(umbrella) {} 134 135 uint32_t getSize() const override { 136 return alignToPowerOf2(sizeof(sub_framework_command) + umbrella.size() + 1, 137 target->wordSize); 138 } 139 140 void writeTo(uint8_t *buf) const override { 141 auto *c = reinterpret_cast<sub_framework_command *>(buf); 142 buf += sizeof(sub_framework_command); 143 144 c->cmd = LC_SUB_FRAMEWORK; 145 c->cmdsize = getSize(); 146 c->umbrella = sizeof(sub_framework_command); 147 148 memcpy(buf, umbrella.data(), umbrella.size()); 149 buf[umbrella.size()] = '\0'; 150 } 151 152 private: 153 const StringRef umbrella; 154 }; 155 156 class LCFunctionStarts final : public LoadCommand { 157 public: 158 explicit LCFunctionStarts(FunctionStartsSection *functionStartsSection) 159 : functionStartsSection(functionStartsSection) {} 160 161 uint32_t getSize() const override { return sizeof(linkedit_data_command); } 162 163 void writeTo(uint8_t *buf) const override { 164 auto *c = reinterpret_cast<linkedit_data_command *>(buf); 165 c->cmd = LC_FUNCTION_STARTS; 166 c->cmdsize = getSize(); 167 c->dataoff = functionStartsSection->fileOff; 168 c->datasize = functionStartsSection->getFileSize(); 169 } 170 171 private: 172 FunctionStartsSection *functionStartsSection; 173 }; 174 175 class LCDataInCode final : public LoadCommand { 176 public: 177 explicit LCDataInCode(DataInCodeSection *dataInCodeSection) 178 : dataInCodeSection(dataInCodeSection) {} 179 180 uint32_t getSize() const override { return sizeof(linkedit_data_command); } 181 182 void writeTo(uint8_t *buf) const override { 183 auto *c = reinterpret_cast<linkedit_data_command *>(buf); 184 c->cmd = LC_DATA_IN_CODE; 185 c->cmdsize = getSize(); 186 c->dataoff = dataInCodeSection->fileOff; 187 c->datasize = dataInCodeSection->getFileSize(); 188 } 189 190 private: 191 DataInCodeSection *dataInCodeSection; 192 }; 193 194 class LCDysymtab final : public LoadCommand { 195 public: 196 LCDysymtab(SymtabSection *symtabSection, 197 IndirectSymtabSection *indirectSymtabSection) 198 : symtabSection(symtabSection), 199 indirectSymtabSection(indirectSymtabSection) {} 200 201 uint32_t getSize() const override { return sizeof(dysymtab_command); } 202 203 void writeTo(uint8_t *buf) const override { 204 auto *c = reinterpret_cast<dysymtab_command *>(buf); 205 c->cmd = LC_DYSYMTAB; 206 c->cmdsize = getSize(); 207 208 c->ilocalsym = 0; 209 c->iextdefsym = c->nlocalsym = symtabSection->getNumLocalSymbols(); 210 c->nextdefsym = symtabSection->getNumExternalSymbols(); 211 c->iundefsym = c->iextdefsym + c->nextdefsym; 212 c->nundefsym = symtabSection->getNumUndefinedSymbols(); 213 214 c->indirectsymoff = indirectSymtabSection->fileOff; 215 c->nindirectsyms = indirectSymtabSection->getNumSymbols(); 216 } 217 218 SymtabSection *symtabSection; 219 IndirectSymtabSection *indirectSymtabSection; 220 }; 221 222 template <class LP> class LCSegment final : public LoadCommand { 223 public: 224 LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {} 225 226 uint32_t getSize() const override { 227 return sizeof(typename LP::segment_command) + 228 seg->numNonHiddenSections() * sizeof(typename LP::section); 229 } 230 231 void writeTo(uint8_t *buf) const override { 232 using SegmentCommand = typename LP::segment_command; 233 using SectionHeader = typename LP::section; 234 235 auto *c = reinterpret_cast<SegmentCommand *>(buf); 236 buf += sizeof(SegmentCommand); 237 238 c->cmd = LP::segmentLCType; 239 c->cmdsize = getSize(); 240 memcpy(c->segname, name.data(), name.size()); 241 c->fileoff = seg->fileOff; 242 c->maxprot = seg->maxProt; 243 c->initprot = seg->initProt; 244 245 c->vmaddr = seg->addr; 246 c->vmsize = seg->vmSize; 247 c->filesize = seg->fileSize; 248 c->nsects = seg->numNonHiddenSections(); 249 c->flags = seg->flags; 250 251 for (const OutputSection *osec : seg->getSections()) { 252 if (osec->isHidden()) 253 continue; 254 255 auto *sectHdr = reinterpret_cast<SectionHeader *>(buf); 256 buf += sizeof(SectionHeader); 257 258 memcpy(sectHdr->sectname, osec->name.data(), osec->name.size()); 259 memcpy(sectHdr->segname, name.data(), name.size()); 260 261 sectHdr->addr = osec->addr; 262 sectHdr->offset = osec->fileOff; 263 sectHdr->align = Log2_32(osec->align); 264 sectHdr->flags = osec->flags; 265 sectHdr->size = osec->getSize(); 266 sectHdr->reserved1 = osec->reserved1; 267 sectHdr->reserved2 = osec->reserved2; 268 } 269 } 270 271 private: 272 StringRef name; 273 OutputSegment *seg; 274 }; 275 276 class LCMain final : public LoadCommand { 277 uint32_t getSize() const override { 278 return sizeof(structs::entry_point_command); 279 } 280 281 void writeTo(uint8_t *buf) const override { 282 auto *c = reinterpret_cast<structs::entry_point_command *>(buf); 283 c->cmd = LC_MAIN; 284 c->cmdsize = getSize(); 285 286 if (config->entry->isInStubs()) 287 c->entryoff = 288 in.stubs->fileOff + config->entry->stubsIndex * target->stubSize; 289 else 290 c->entryoff = config->entry->getVA() - in.header->addr; 291 292 c->stacksize = 0; 293 } 294 }; 295 296 class LCSymtab final : public LoadCommand { 297 public: 298 LCSymtab(SymtabSection *symtabSection, StringTableSection *stringTableSection) 299 : symtabSection(symtabSection), stringTableSection(stringTableSection) {} 300 301 uint32_t getSize() const override { return sizeof(symtab_command); } 302 303 void writeTo(uint8_t *buf) const override { 304 auto *c = reinterpret_cast<symtab_command *>(buf); 305 c->cmd = LC_SYMTAB; 306 c->cmdsize = getSize(); 307 c->symoff = symtabSection->fileOff; 308 c->nsyms = symtabSection->getNumSymbols(); 309 c->stroff = stringTableSection->fileOff; 310 c->strsize = stringTableSection->getFileSize(); 311 } 312 313 SymtabSection *symtabSection = nullptr; 314 StringTableSection *stringTableSection = nullptr; 315 }; 316 317 // There are several dylib load commands that share the same structure: 318 // * LC_LOAD_DYLIB 319 // * LC_ID_DYLIB 320 // * LC_REEXPORT_DYLIB 321 class LCDylib final : public LoadCommand { 322 public: 323 LCDylib(LoadCommandType type, StringRef path, 324 uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0) 325 : type(type), path(path), compatibilityVersion(compatibilityVersion), 326 currentVersion(currentVersion) { 327 instanceCount++; 328 } 329 330 uint32_t getSize() const override { 331 return alignToPowerOf2(sizeof(dylib_command) + path.size() + 1, 332 target->wordSize); 333 } 334 335 void writeTo(uint8_t *buf) const override { 336 auto *c = reinterpret_cast<dylib_command *>(buf); 337 buf += sizeof(dylib_command); 338 339 c->cmd = type; 340 c->cmdsize = getSize(); 341 c->dylib.name = sizeof(dylib_command); 342 c->dylib.timestamp = 0; 343 c->dylib.compatibility_version = compatibilityVersion; 344 c->dylib.current_version = currentVersion; 345 346 memcpy(buf, path.data(), path.size()); 347 buf[path.size()] = '\0'; 348 } 349 350 static uint32_t getInstanceCount() { return instanceCount; } 351 static void resetInstanceCount() { instanceCount = 0; } 352 353 private: 354 LoadCommandType type; 355 StringRef path; 356 uint32_t compatibilityVersion; 357 uint32_t currentVersion; 358 static uint32_t instanceCount; 359 }; 360 361 uint32_t LCDylib::instanceCount = 0; 362 363 class LCLoadDylinker final : public LoadCommand { 364 public: 365 uint32_t getSize() const override { 366 return alignToPowerOf2(sizeof(dylinker_command) + path.size() + 1, 367 target->wordSize); 368 } 369 370 void writeTo(uint8_t *buf) const override { 371 auto *c = reinterpret_cast<dylinker_command *>(buf); 372 buf += sizeof(dylinker_command); 373 374 c->cmd = LC_LOAD_DYLINKER; 375 c->cmdsize = getSize(); 376 c->name = sizeof(dylinker_command); 377 378 memcpy(buf, path.data(), path.size()); 379 buf[path.size()] = '\0'; 380 } 381 382 private: 383 // Recent versions of Darwin won't run any binary that has dyld at a 384 // different location. 385 const StringRef path = "/usr/lib/dyld"; 386 }; 387 388 class LCRPath final : public LoadCommand { 389 public: 390 explicit LCRPath(StringRef path) : path(path) {} 391 392 uint32_t getSize() const override { 393 return alignToPowerOf2(sizeof(rpath_command) + path.size() + 1, 394 target->wordSize); 395 } 396 397 void writeTo(uint8_t *buf) const override { 398 auto *c = reinterpret_cast<rpath_command *>(buf); 399 buf += sizeof(rpath_command); 400 401 c->cmd = LC_RPATH; 402 c->cmdsize = getSize(); 403 c->path = sizeof(rpath_command); 404 405 memcpy(buf, path.data(), path.size()); 406 buf[path.size()] = '\0'; 407 } 408 409 private: 410 StringRef path; 411 }; 412 413 class LCDyldEnv final : public LoadCommand { 414 public: 415 explicit LCDyldEnv(StringRef name) : name(name) {} 416 417 uint32_t getSize() const override { 418 return alignToPowerOf2(sizeof(dyld_env_command) + name.size() + 1, 419 target->wordSize); 420 } 421 422 void writeTo(uint8_t *buf) const override { 423 auto *c = reinterpret_cast<dyld_env_command *>(buf); 424 buf += sizeof(dyld_env_command); 425 426 c->cmd = LC_DYLD_ENVIRONMENT; 427 c->cmdsize = getSize(); 428 c->name = sizeof(dyld_env_command); 429 430 memcpy(buf, name.data(), name.size()); 431 buf[name.size()] = '\0'; 432 } 433 434 private: 435 StringRef name; 436 }; 437 438 class LCMinVersion final : public LoadCommand { 439 public: 440 explicit LCMinVersion(const PlatformInfo &platformInfo) 441 : platformInfo(platformInfo) {} 442 443 uint32_t getSize() const override { return sizeof(version_min_command); } 444 445 void writeTo(uint8_t *buf) const override { 446 auto *c = reinterpret_cast<version_min_command *>(buf); 447 switch (platformInfo.target.Platform) { 448 case PLATFORM_MACOS: 449 c->cmd = LC_VERSION_MIN_MACOSX; 450 break; 451 case PLATFORM_IOS: 452 case PLATFORM_IOSSIMULATOR: 453 c->cmd = LC_VERSION_MIN_IPHONEOS; 454 break; 455 case PLATFORM_TVOS: 456 case PLATFORM_TVOSSIMULATOR: 457 c->cmd = LC_VERSION_MIN_TVOS; 458 break; 459 case PLATFORM_WATCHOS: 460 case PLATFORM_WATCHOSSIMULATOR: 461 c->cmd = LC_VERSION_MIN_WATCHOS; 462 break; 463 default: 464 llvm_unreachable("invalid platform"); 465 break; 466 } 467 c->cmdsize = getSize(); 468 c->version = encodeVersion(platformInfo.minimum); 469 c->sdk = encodeVersion(platformInfo.sdk); 470 } 471 472 private: 473 const PlatformInfo &platformInfo; 474 }; 475 476 class LCBuildVersion final : public LoadCommand { 477 public: 478 explicit LCBuildVersion(const PlatformInfo &platformInfo) 479 : platformInfo(platformInfo) {} 480 481 const int ntools = 1; 482 483 uint32_t getSize() const override { 484 return sizeof(build_version_command) + ntools * sizeof(build_tool_version); 485 } 486 487 void writeTo(uint8_t *buf) const override { 488 auto *c = reinterpret_cast<build_version_command *>(buf); 489 c->cmd = LC_BUILD_VERSION; 490 c->cmdsize = getSize(); 491 492 c->platform = static_cast<uint32_t>(platformInfo.target.Platform); 493 c->minos = encodeVersion(platformInfo.minimum); 494 c->sdk = encodeVersion(platformInfo.sdk); 495 496 c->ntools = ntools; 497 auto *t = reinterpret_cast<build_tool_version *>(&c[1]); 498 t->tool = TOOL_LD; 499 t->version = encodeVersion(VersionTuple( 500 LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR, LLVM_VERSION_PATCH)); 501 } 502 503 private: 504 const PlatformInfo &platformInfo; 505 }; 506 507 // Stores a unique identifier for the output file based on an MD5 hash of its 508 // contents. In order to hash the contents, we must first write them, but 509 // LC_UUID itself must be part of the written contents in order for all the 510 // offsets to be calculated correctly. We resolve this circular paradox by 511 // first writing an LC_UUID with an all-zero UUID, then updating the UUID with 512 // its real value later. 513 class LCUuid final : public LoadCommand { 514 public: 515 uint32_t getSize() const override { return sizeof(uuid_command); } 516 517 void writeTo(uint8_t *buf) const override { 518 auto *c = reinterpret_cast<uuid_command *>(buf); 519 c->cmd = LC_UUID; 520 c->cmdsize = getSize(); 521 uuidBuf = c->uuid; 522 } 523 524 void writeUuid(uint64_t digest) const { 525 // xxhash only gives us 8 bytes, so put some fixed data in the other half. 526 static_assert(sizeof(uuid_command::uuid) == 16, "unexpected uuid size"); 527 memcpy(uuidBuf, "LLD\xa1UU1D", 8); 528 memcpy(uuidBuf + 8, &digest, 8); 529 530 // RFC 4122 conformance. We need to fix 4 bits in byte 6 and 2 bits in 531 // byte 8. Byte 6 is already fine due to the fixed data we put in. We don't 532 // want to lose bits of the digest in byte 8, so swap that with a byte of 533 // fixed data that happens to have the right bits set. 534 std::swap(uuidBuf[3], uuidBuf[8]); 535 536 // Claim that this is an MD5-based hash. It isn't, but this signals that 537 // this is not a time-based and not a random hash. MD5 seems like the least 538 // bad lie we can put here. 539 assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3"); 540 assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 Section 4.2.2"); 541 } 542 543 mutable uint8_t *uuidBuf; 544 }; 545 546 template <class LP> class LCEncryptionInfo final : public LoadCommand { 547 public: 548 uint32_t getSize() const override { 549 return sizeof(typename LP::encryption_info_command); 550 } 551 552 void writeTo(uint8_t *buf) const override { 553 using EncryptionInfo = typename LP::encryption_info_command; 554 auto *c = reinterpret_cast<EncryptionInfo *>(buf); 555 buf += sizeof(EncryptionInfo); 556 c->cmd = LP::encryptionInfoLCType; 557 c->cmdsize = getSize(); 558 c->cryptoff = in.header->getSize(); 559 auto it = find_if(outputSegments, [](const OutputSegment *seg) { 560 return seg->name == segment_names::text; 561 }); 562 assert(it != outputSegments.end()); 563 c->cryptsize = (*it)->fileSize - c->cryptoff; 564 } 565 }; 566 567 class LCCodeSignature final : public LoadCommand { 568 public: 569 LCCodeSignature(CodeSignatureSection *section) : section(section) {} 570 571 uint32_t getSize() const override { return sizeof(linkedit_data_command); } 572 573 void writeTo(uint8_t *buf) const override { 574 auto *c = reinterpret_cast<linkedit_data_command *>(buf); 575 c->cmd = LC_CODE_SIGNATURE; 576 c->cmdsize = getSize(); 577 c->dataoff = static_cast<uint32_t>(section->fileOff); 578 c->datasize = section->getSize(); 579 } 580 581 CodeSignatureSection *section; 582 }; 583 584 class LCExportsTrie final : public LoadCommand { 585 public: 586 LCExportsTrie(ExportSection *section) : section(section) {} 587 588 uint32_t getSize() const override { return sizeof(linkedit_data_command); } 589 590 void writeTo(uint8_t *buf) const override { 591 auto *c = reinterpret_cast<linkedit_data_command *>(buf); 592 c->cmd = LC_DYLD_EXPORTS_TRIE; 593 c->cmdsize = getSize(); 594 c->dataoff = section->fileOff; 595 c->datasize = section->getSize(); 596 } 597 598 ExportSection *section; 599 }; 600 601 class LCChainedFixups final : public LoadCommand { 602 public: 603 LCChainedFixups(ChainedFixupsSection *section) : section(section) {} 604 605 uint32_t getSize() const override { return sizeof(linkedit_data_command); } 606 607 void writeTo(uint8_t *buf) const override { 608 auto *c = reinterpret_cast<linkedit_data_command *>(buf); 609 c->cmd = LC_DYLD_CHAINED_FIXUPS; 610 c->cmdsize = getSize(); 611 c->dataoff = section->fileOff; 612 c->datasize = section->getSize(); 613 } 614 615 ChainedFixupsSection *section; 616 }; 617 618 } // namespace 619 620 void Writer::treatSpecialUndefineds() { 621 if (config->entry) 622 if (auto *undefined = dyn_cast<Undefined>(config->entry)) 623 treatUndefinedSymbol(*undefined, "the entry point"); 624 625 // FIXME: This prints symbols that are undefined both in input files and 626 // via -u flag twice. 627 for (const Symbol *sym : config->explicitUndefineds) { 628 if (const auto *undefined = dyn_cast<Undefined>(sym)) 629 treatUndefinedSymbol(*undefined, "-u"); 630 } 631 // Literal exported-symbol names must be defined, but glob 632 // patterns need not match. 633 for (const CachedHashStringRef &cachedName : 634 config->exportedSymbols.literals) { 635 if (const Symbol *sym = symtab->find(cachedName)) 636 if (const auto *undefined = dyn_cast<Undefined>(sym)) 637 treatUndefinedSymbol(*undefined, "-exported_symbol(s_list)"); 638 } 639 } 640 641 static void prepareSymbolRelocation(Symbol *sym, const InputSection *isec, 642 const lld::macho::Reloc &r) { 643 assert(sym->isLive()); 644 const RelocAttrs &relocAttrs = target->getRelocAttrs(r.type); 645 646 if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) { 647 if (needsBinding(sym)) 648 in.stubs->addEntry(sym); 649 } else if (relocAttrs.hasAttr(RelocAttrBits::GOT)) { 650 if (relocAttrs.hasAttr(RelocAttrBits::POINTER) || needsBinding(sym)) 651 in.got->addEntry(sym); 652 } else if (relocAttrs.hasAttr(RelocAttrBits::TLV)) { 653 if (needsBinding(sym)) 654 in.tlvPointers->addEntry(sym); 655 } else if (relocAttrs.hasAttr(RelocAttrBits::UNSIGNED)) { 656 // References from thread-local variable sections are treated as offsets 657 // relative to the start of the referent section, and therefore have no 658 // need of rebase opcodes. 659 if (!(isThreadLocalVariables(isec->getFlags()) && isa<Defined>(sym))) 660 addNonLazyBindingEntries(sym, isec, r.offset, r.addend); 661 } 662 } 663 664 void Writer::scanRelocations() { 665 TimeTraceScope timeScope("Scan relocations"); 666 667 // This can't use a for-each loop: It calls treatUndefinedSymbol(), which can 668 // add to inputSections, which invalidates inputSections's iterators. 669 for (size_t i = 0; i < inputSections.size(); ++i) { 670 ConcatInputSection *isec = inputSections[i]; 671 672 if (isec->shouldOmitFromOutput()) 673 continue; 674 675 for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) { 676 lld::macho::Reloc &r = *it; 677 if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) { 678 // Skip over the following UNSIGNED relocation -- it's just there as the 679 // minuend, and doesn't have the usual UNSIGNED semantics. We don't want 680 // to emit rebase opcodes for it. 681 it++; 682 continue; 683 } 684 if (auto *sym = r.referent.dyn_cast<Symbol *>()) { 685 if (auto *undefined = dyn_cast<Undefined>(sym)) 686 treatUndefinedSymbol(*undefined, isec, r.offset); 687 // treatUndefinedSymbol() can replace sym with a DylibSymbol; re-check. 688 if (!isa<Undefined>(sym) && validateSymbolRelocation(sym, isec, r)) 689 prepareSymbolRelocation(sym, isec, r); 690 } else { 691 // Canonicalize the referent so that later accesses in Writer won't 692 // have to worry about it. Perhaps we should do this for Defined::isec 693 // too... 694 auto *referentIsec = r.referent.get<InputSection *>(); 695 r.referent = referentIsec->canonical(); 696 if (!r.pcrel) { 697 if (config->emitChainedFixups) 698 in.chainedFixups->addRebase(isec, r.offset); 699 else 700 in.rebase->addEntry(isec, r.offset); 701 } 702 } 703 } 704 } 705 706 in.unwindInfo->prepare(); 707 } 708 709 static void addNonWeakDefinition(const Defined *defined) { 710 if (config->emitChainedFixups) 711 in.chainedFixups->setHasNonWeakDefinition(); 712 else 713 in.weakBinding->addNonWeakDefinition(defined); 714 } 715 716 void Writer::scanSymbols() { 717 TimeTraceScope timeScope("Scan symbols"); 718 for (Symbol *sym : symtab->getSymbols()) { 719 if (auto *defined = dyn_cast<Defined>(sym)) { 720 if (!defined->isLive()) 721 continue; 722 defined->canonicalize(); 723 if (defined->overridesWeakDef) 724 addNonWeakDefinition(defined); 725 if (!defined->isAbsolute() && isCodeSection(defined->isec)) 726 in.unwindInfo->addSymbol(defined); 727 } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) { 728 // This branch intentionally doesn't check isLive(). 729 if (dysym->isDynamicLookup()) 730 continue; 731 dysym->getFile()->refState = 732 std::max(dysym->getFile()->refState, dysym->getRefState()); 733 } else if (isa<Undefined>(sym)) { 734 if (sym->getName().startswith(ObjCStubsSection::symbolPrefix)) 735 in.objcStubs->addEntry(sym); 736 } 737 } 738 739 for (const InputFile *file : inputFiles) { 740 if (auto *objFile = dyn_cast<ObjFile>(file)) 741 for (Symbol *sym : objFile->symbols) { 742 if (auto *defined = dyn_cast_or_null<Defined>(sym)) { 743 if (!defined->isLive()) 744 continue; 745 defined->canonicalize(); 746 if (!defined->isExternal() && !defined->isAbsolute() && 747 isCodeSection(defined->isec)) 748 in.unwindInfo->addSymbol(defined); 749 } 750 } 751 } 752 } 753 754 // TODO: ld64 enforces the old load commands in a few other cases. 755 static bool useLCBuildVersion(const PlatformInfo &platformInfo) { 756 static const std::array<std::pair<PlatformType, VersionTuple>, 7> minVersion = 757 {{{PLATFORM_MACOS, VersionTuple(10, 14)}, 758 {PLATFORM_IOS, VersionTuple(12, 0)}, 759 {PLATFORM_IOSSIMULATOR, VersionTuple(13, 0)}, 760 {PLATFORM_TVOS, VersionTuple(12, 0)}, 761 {PLATFORM_TVOSSIMULATOR, VersionTuple(13, 0)}, 762 {PLATFORM_WATCHOS, VersionTuple(5, 0)}, 763 {PLATFORM_WATCHOSSIMULATOR, VersionTuple(6, 0)}}}; 764 auto it = llvm::find_if(minVersion, [&](const auto &p) { 765 return p.first == platformInfo.target.Platform; 766 }); 767 return it == minVersion.end() ? true : platformInfo.minimum >= it->second; 768 } 769 770 template <class LP> void Writer::createLoadCommands() { 771 uint8_t segIndex = 0; 772 for (OutputSegment *seg : outputSegments) { 773 in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg)); 774 seg->index = segIndex++; 775 } 776 777 if (config->emitChainedFixups) { 778 in.header->addLoadCommand(make<LCChainedFixups>(in.chainedFixups)); 779 in.header->addLoadCommand(make<LCExportsTrie>(in.exports)); 780 } else { 781 in.header->addLoadCommand(make<LCDyldInfo>( 782 in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports)); 783 } 784 in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection)); 785 in.header->addLoadCommand( 786 make<LCDysymtab>(symtabSection, indirectSymtabSection)); 787 if (!config->umbrella.empty()) 788 in.header->addLoadCommand(make<LCSubFramework>(config->umbrella)); 789 if (config->emitEncryptionInfo) 790 in.header->addLoadCommand(make<LCEncryptionInfo<LP>>()); 791 for (StringRef path : config->runtimePaths) 792 in.header->addLoadCommand(make<LCRPath>(path)); 793 794 switch (config->outputType) { 795 case MH_EXECUTE: 796 in.header->addLoadCommand(make<LCLoadDylinker>()); 797 break; 798 case MH_DYLIB: 799 in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName, 800 config->dylibCompatibilityVersion, 801 config->dylibCurrentVersion)); 802 break; 803 case MH_BUNDLE: 804 break; 805 default: 806 llvm_unreachable("unhandled output file type"); 807 } 808 809 uuidCommand = make<LCUuid>(); 810 in.header->addLoadCommand(uuidCommand); 811 812 if (useLCBuildVersion(config->platformInfo)) 813 in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo)); 814 else 815 in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo)); 816 817 if (config->secondaryPlatformInfo) { 818 in.header->addLoadCommand( 819 make<LCBuildVersion>(*config->secondaryPlatformInfo)); 820 } 821 822 // This is down here to match ld64's load command order. 823 if (config->outputType == MH_EXECUTE) 824 in.header->addLoadCommand(make<LCMain>()); 825 826 // See ld64's OutputFile::buildDylibOrdinalMapping for the corresponding 827 // library ordinal computation code in ld64. 828 int64_t dylibOrdinal = 1; 829 DenseMap<StringRef, int64_t> ordinalForInstallName; 830 831 std::vector<DylibFile *> dylibFiles; 832 for (InputFile *file : inputFiles) { 833 if (auto *dylibFile = dyn_cast<DylibFile>(file)) 834 dylibFiles.push_back(dylibFile); 835 } 836 for (size_t i = 0; i < dylibFiles.size(); ++i) 837 dylibFiles.insert(dylibFiles.end(), dylibFiles[i]->extraDylibs.begin(), 838 dylibFiles[i]->extraDylibs.end()); 839 840 for (DylibFile *dylibFile : dylibFiles) { 841 if (dylibFile->isBundleLoader) { 842 dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE; 843 // Shortcut since bundle-loader does not re-export the symbols. 844 845 dylibFile->reexport = false; 846 continue; 847 } 848 849 // Don't emit load commands for a dylib that is not referenced if: 850 // - it was added implicitly (via a reexport, an LC_LOAD_DYLINKER -- 851 // if it's on the linker command line, it's explicit) 852 // - or it's marked MH_DEAD_STRIPPABLE_DYLIB 853 // - or the flag -dead_strip_dylibs is used 854 // FIXME: `isReferenced()` is currently computed before dead code 855 // stripping, so references from dead code keep a dylib alive. This 856 // matches ld64, but it's something we should do better. 857 if (!dylibFile->isReferenced() && !dylibFile->forceNeeded && 858 (!dylibFile->isExplicitlyLinked() || dylibFile->deadStrippable || 859 config->deadStripDylibs)) 860 continue; 861 862 // Several DylibFiles can have the same installName. Only emit a single 863 // load command for that installName and give all these DylibFiles the 864 // same ordinal. 865 // This can happen in several cases: 866 // - a new framework could change its installName to an older 867 // framework name via an $ld$ symbol depending on platform_version 868 // - symlinks (for example, libpthread.tbd is a symlink to libSystem.tbd; 869 // Foo.framework/Foo.tbd is usually a symlink to 870 // Foo.framework/Versions/Current/Foo.tbd, where 871 // Foo.framework/Versions/Current is usually a symlink to 872 // Foo.framework/Versions/A) 873 // - a framework can be linked both explicitly on the linker 874 // command line and implicitly as a reexport from a different 875 // framework. The re-export will usually point to the tbd file 876 // in Foo.framework/Versions/A/Foo.tbd, while the explicit link will 877 // usually find Foo.framework/Foo.tbd. These are usually symlinks, 878 // but in a --reproduce archive they will be identical but distinct 879 // files. 880 // In the first case, *semantically distinct* DylibFiles will have the 881 // same installName. 882 int64_t &ordinal = ordinalForInstallName[dylibFile->installName]; 883 if (ordinal) { 884 dylibFile->ordinal = ordinal; 885 continue; 886 } 887 888 ordinal = dylibFile->ordinal = dylibOrdinal++; 889 LoadCommandType lcType = 890 dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak 891 ? LC_LOAD_WEAK_DYLIB 892 : LC_LOAD_DYLIB; 893 in.header->addLoadCommand(make<LCDylib>(lcType, dylibFile->installName, 894 dylibFile->compatibilityVersion, 895 dylibFile->currentVersion)); 896 897 if (dylibFile->reexport) 898 in.header->addLoadCommand( 899 make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->installName)); 900 } 901 902 for (const auto &dyldEnv : config->dyldEnvs) 903 in.header->addLoadCommand(make<LCDyldEnv>(dyldEnv)); 904 905 if (functionStartsSection) 906 in.header->addLoadCommand(make<LCFunctionStarts>(functionStartsSection)); 907 if (dataInCodeSection) 908 in.header->addLoadCommand(make<LCDataInCode>(dataInCodeSection)); 909 if (codeSignatureSection) 910 in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection)); 911 912 const uint32_t MACOS_MAXPATHLEN = 1024; 913 config->headerPad = std::max( 914 config->headerPad, (config->headerPadMaxInstallNames 915 ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN 916 : 0)); 917 } 918 919 // Sorting only can happen once all outputs have been collected. Here we sort 920 // segments, output sections within each segment, and input sections within each 921 // output segment. 922 static void sortSegmentsAndSections() { 923 TimeTraceScope timeScope("Sort segments and sections"); 924 sortOutputSegments(); 925 926 DenseMap<const InputSection *, size_t> isecPriorities = 927 priorityBuilder.buildInputSectionPriorities(); 928 929 uint32_t sectionIndex = 0; 930 for (OutputSegment *seg : outputSegments) { 931 seg->sortOutputSections(); 932 // References from thread-local variable sections are treated as offsets 933 // relative to the start of the thread-local data memory area, which 934 // is initialized via copying all the TLV data sections (which are all 935 // contiguous). If later data sections require a greater alignment than 936 // earlier ones, the offsets of data within those sections won't be 937 // guaranteed to aligned unless we normalize alignments. We therefore use 938 // the largest alignment for all TLV data sections. 939 uint32_t tlvAlign = 0; 940 for (const OutputSection *osec : seg->getSections()) 941 if (isThreadLocalData(osec->flags) && osec->align > tlvAlign) 942 tlvAlign = osec->align; 943 944 for (OutputSection *osec : seg->getSections()) { 945 // Now that the output sections are sorted, assign the final 946 // output section indices. 947 if (!osec->isHidden()) 948 osec->index = ++sectionIndex; 949 if (isThreadLocalData(osec->flags)) { 950 if (!firstTLVDataSection) 951 firstTLVDataSection = osec; 952 osec->align = tlvAlign; 953 } 954 955 if (!isecPriorities.empty()) { 956 if (auto *merged = dyn_cast<ConcatOutputSection>(osec)) { 957 llvm::stable_sort( 958 merged->inputs, [&](InputSection *a, InputSection *b) { 959 return isecPriorities.lookup(a) > isecPriorities.lookup(b); 960 }); 961 } 962 } 963 } 964 } 965 } 966 967 template <class LP> void Writer::createOutputSections() { 968 TimeTraceScope timeScope("Create output sections"); 969 // First, create hidden sections 970 stringTableSection = make<StringTableSection>(); 971 symtabSection = makeSymtabSection<LP>(*stringTableSection); 972 indirectSymtabSection = make<IndirectSymtabSection>(); 973 if (config->adhocCodesign) 974 codeSignatureSection = make<CodeSignatureSection>(); 975 if (config->emitDataInCodeInfo) 976 dataInCodeSection = make<DataInCodeSection>(); 977 if (config->emitFunctionStarts) 978 functionStartsSection = make<FunctionStartsSection>(); 979 if (config->emitBitcodeBundle) 980 make<BitcodeBundleSection>(); 981 982 switch (config->outputType) { 983 case MH_EXECUTE: 984 make<PageZeroSection>(); 985 break; 986 case MH_DYLIB: 987 case MH_BUNDLE: 988 break; 989 default: 990 llvm_unreachable("unhandled output file type"); 991 } 992 993 // Then add input sections to output sections. 994 for (ConcatInputSection *isec : inputSections) { 995 if (isec->shouldOmitFromOutput()) 996 continue; 997 ConcatOutputSection *osec = cast<ConcatOutputSection>(isec->parent); 998 osec->addInput(isec); 999 osec->inputOrder = 1000 std::min(osec->inputOrder, static_cast<int>(isec->outSecOff)); 1001 } 1002 1003 // Once all the inputs are added, we can finalize the output section 1004 // properties and create the corresponding output segments. 1005 for (const auto &it : concatOutputSections) { 1006 StringRef segname = it.first.first; 1007 ConcatOutputSection *osec = it.second; 1008 assert(segname != segment_names::ld); 1009 if (osec->isNeeded()) { 1010 // See comment in ObjFile::splitEhFrames() 1011 if (osec->name == section_names::ehFrame && 1012 segname == segment_names::text) 1013 osec->align = target->wordSize; 1014 1015 // MC keeps the default 1-byte alignment for __thread_vars, even though it 1016 // contains pointers that are fixed up by dyld, which requires proper 1017 // alignment. 1018 if (isThreadLocalVariables(osec->flags)) 1019 osec->align = std::max<uint32_t>(osec->align, target->wordSize); 1020 1021 getOrCreateOutputSegment(segname)->addOutputSection(osec); 1022 } 1023 } 1024 1025 for (SyntheticSection *ssec : syntheticSections) { 1026 auto it = concatOutputSections.find({ssec->segname, ssec->name}); 1027 // We add all LinkEdit sections here because we don't know if they are 1028 // needed until their finalizeContents() methods get called later. While 1029 // this means that we add some redundant sections to __LINKEDIT, there is 1030 // is no redundancy in the output, as we do not emit section headers for 1031 // any LinkEdit sections. 1032 if (ssec->isNeeded() || ssec->segname == segment_names::linkEdit) { 1033 if (it == concatOutputSections.end()) { 1034 getOrCreateOutputSegment(ssec->segname)->addOutputSection(ssec); 1035 } else { 1036 fatal("section from " + 1037 toString(it->second->firstSection()->getFile()) + 1038 " conflicts with synthetic section " + ssec->segname + "," + 1039 ssec->name); 1040 } 1041 } 1042 } 1043 1044 // dyld requires __LINKEDIT segment to always exist (even if empty). 1045 linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit); 1046 } 1047 1048 void Writer::finalizeAddresses() { 1049 TimeTraceScope timeScope("Finalize addresses"); 1050 uint64_t pageSize = target->getPageSize(); 1051 1052 // We could parallelize this loop, but local benchmarking indicates it is 1053 // faster to do it all in the main thread. 1054 for (OutputSegment *seg : outputSegments) { 1055 if (seg == linkEditSegment) 1056 continue; 1057 for (OutputSection *osec : seg->getSections()) { 1058 if (!osec->isNeeded()) 1059 continue; 1060 // Other kinds of OutputSections have already been finalized. 1061 if (auto concatOsec = dyn_cast<ConcatOutputSection>(osec)) 1062 concatOsec->finalizeContents(); 1063 } 1064 } 1065 1066 // Ensure that segments (and the sections they contain) are allocated 1067 // addresses in ascending order, which dyld requires. 1068 // 1069 // Note that at this point, __LINKEDIT sections are empty, but we need to 1070 // determine addresses of other segments/sections before generating its 1071 // contents. 1072 for (OutputSegment *seg : outputSegments) { 1073 if (seg == linkEditSegment) 1074 continue; 1075 seg->addr = addr; 1076 assignAddresses(seg); 1077 // codesign / libstuff checks for segment ordering by verifying that 1078 // `fileOff + fileSize == next segment fileOff`. So we call alignTo() before 1079 // (instead of after) computing fileSize to ensure that the segments are 1080 // contiguous. We handle addr / vmSize similarly for the same reason. 1081 fileOff = alignToPowerOf2(fileOff, pageSize); 1082 addr = alignToPowerOf2(addr, pageSize); 1083 seg->vmSize = addr - seg->addr; 1084 seg->fileSize = fileOff - seg->fileOff; 1085 seg->assignAddressesToStartEndSymbols(); 1086 } 1087 } 1088 1089 void Writer::finalizeLinkEditSegment() { 1090 TimeTraceScope timeScope("Finalize __LINKEDIT segment"); 1091 // Fill __LINKEDIT contents. 1092 std::array<LinkEditSection *, 10> linkEditSections{ 1093 in.rebase, in.binding, 1094 in.weakBinding, in.lazyBinding, 1095 in.exports, in.chainedFixups, 1096 symtabSection, indirectSymtabSection, 1097 dataInCodeSection, functionStartsSection, 1098 }; 1099 SmallVector<std::shared_future<void>> threadFutures; 1100 threadFutures.reserve(linkEditSections.size()); 1101 for (LinkEditSection *osec : linkEditSections) 1102 if (osec) 1103 threadFutures.emplace_back(threadPool.async( 1104 [](LinkEditSection *osec) { osec->finalizeContents(); }, osec)); 1105 for (std::shared_future<void> &future : threadFutures) 1106 future.wait(); 1107 1108 // Now that __LINKEDIT is filled out, do a proper calculation of its 1109 // addresses and offsets. 1110 linkEditSegment->addr = addr; 1111 assignAddresses(linkEditSegment); 1112 // No need to page-align fileOff / addr here since this is the last segment. 1113 linkEditSegment->vmSize = addr - linkEditSegment->addr; 1114 linkEditSegment->fileSize = fileOff - linkEditSegment->fileOff; 1115 } 1116 1117 void Writer::assignAddresses(OutputSegment *seg) { 1118 seg->fileOff = fileOff; 1119 1120 for (OutputSection *osec : seg->getSections()) { 1121 if (!osec->isNeeded()) 1122 continue; 1123 addr = alignTo(addr, osec->align); 1124 fileOff = alignTo(fileOff, osec->align); 1125 osec->addr = addr; 1126 osec->fileOff = isZeroFill(osec->flags) ? 0 : fileOff; 1127 osec->finalize(); 1128 osec->assignAddressesToStartEndSymbols(); 1129 1130 addr += osec->getSize(); 1131 fileOff += osec->getFileSize(); 1132 } 1133 } 1134 1135 void Writer::openFile() { 1136 Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr = 1137 FileOutputBuffer::create(config->outputFile, fileOff, 1138 FileOutputBuffer::F_executable); 1139 1140 if (!bufferOrErr) 1141 fatal("failed to open " + config->outputFile + ": " + 1142 llvm::toString(bufferOrErr.takeError())); 1143 buffer = std::move(*bufferOrErr); 1144 in.bufferStart = buffer->getBufferStart(); 1145 } 1146 1147 void Writer::writeSections() { 1148 uint8_t *buf = buffer->getBufferStart(); 1149 std::vector<const OutputSection *> osecs; 1150 for (const OutputSegment *seg : outputSegments) 1151 append_range(osecs, seg->getSections()); 1152 1153 parallelForEach(osecs.begin(), osecs.end(), [&](const OutputSection *osec) { 1154 osec->writeTo(buf + osec->fileOff); 1155 }); 1156 } 1157 1158 void Writer::applyOptimizationHints() { 1159 if (config->arch() != AK_arm64 || config->ignoreOptimizationHints) 1160 return; 1161 1162 uint8_t *buf = buffer->getBufferStart(); 1163 TimeTraceScope timeScope("Apply linker optimization hints"); 1164 parallelForEach(inputFiles, [buf](const InputFile *file) { 1165 if (const auto *objFile = dyn_cast<ObjFile>(file)) 1166 target->applyOptimizationHints(buf, *objFile); 1167 }); 1168 } 1169 1170 // In order to utilize multiple cores, we first split the buffer into chunks, 1171 // compute a hash for each chunk, and then compute a hash value of the hash 1172 // values. 1173 void Writer::writeUuid() { 1174 TimeTraceScope timeScope("Computing UUID"); 1175 1176 ArrayRef<uint8_t> data{buffer->getBufferStart(), buffer->getBufferEnd()}; 1177 unsigned chunkCount = parallel::strategy.compute_thread_count() * 10; 1178 // Round-up integer division 1179 size_t chunkSize = (data.size() + chunkCount - 1) / chunkCount; 1180 std::vector<ArrayRef<uint8_t>> chunks = split(data, chunkSize); 1181 // Leave one slot for filename 1182 std::vector<uint64_t> hashes(chunks.size() + 1); 1183 SmallVector<std::shared_future<void>> threadFutures; 1184 threadFutures.reserve(chunks.size()); 1185 for (size_t i = 0; i < chunks.size(); ++i) 1186 threadFutures.emplace_back(threadPool.async( 1187 [&](size_t j) { hashes[j] = xxHash64(chunks[j]); }, i)); 1188 for (std::shared_future<void> &future : threadFutures) 1189 future.wait(); 1190 // Append the output filename so that identical binaries with different names 1191 // don't get the same UUID. 1192 hashes[chunks.size()] = xxHash64(sys::path::filename(config->finalOutput)); 1193 uint64_t digest = xxHash64({reinterpret_cast<uint8_t *>(hashes.data()), 1194 hashes.size() * sizeof(uint64_t)}); 1195 uuidCommand->writeUuid(digest); 1196 } 1197 1198 // This is step 5 of the algorithm described in the class comment of 1199 // ChainedFixupsSection. 1200 void Writer::buildFixupChains() { 1201 if (!config->emitChainedFixups) 1202 return; 1203 1204 const std::vector<Location> &loc = in.chainedFixups->getLocations(); 1205 if (loc.empty()) 1206 return; 1207 1208 TimeTraceScope timeScope("Build fixup chains"); 1209 1210 const uint64_t pageSize = target->getPageSize(); 1211 constexpr uint32_t stride = 4; // for DYLD_CHAINED_PTR_64 1212 1213 for (size_t i = 0, count = loc.size(); i < count;) { 1214 const OutputSegment *oseg = loc[i].isec->parent->parent; 1215 uint8_t *buf = buffer->getBufferStart() + oseg->fileOff; 1216 uint64_t pageIdx = loc[i].offset / pageSize; 1217 ++i; 1218 1219 while (i < count && loc[i].isec->parent->parent == oseg && 1220 (loc[i].offset / pageSize) == pageIdx) { 1221 uint64_t offset = loc[i].offset - loc[i - 1].offset; 1222 1223 auto fail = [&](Twine message) { 1224 error(loc[i].isec->getSegName() + "," + loc[i].isec->getName() + 1225 ", offset " + 1226 Twine(loc[i].offset - loc[i].isec->parent->getSegmentOffset()) + 1227 ": " + message); 1228 }; 1229 1230 if (offset < target->wordSize) 1231 return fail("fixups overlap"); 1232 if (offset % stride != 0) 1233 return fail( 1234 "fixups are unaligned (offset " + Twine(offset) + 1235 " is not a multiple of the stride). Re-link with -no_fixup_chains"); 1236 1237 // The "next" field is in the same location for bind and rebase entries. 1238 reinterpret_cast<dyld_chained_ptr_64_bind *>(buf + loc[i - 1].offset) 1239 ->next = offset / stride; 1240 ++i; 1241 } 1242 } 1243 } 1244 1245 void Writer::writeCodeSignature() { 1246 if (codeSignatureSection) { 1247 TimeTraceScope timeScope("Write code signature"); 1248 codeSignatureSection->writeHashes(buffer->getBufferStart()); 1249 } 1250 } 1251 1252 void Writer::writeOutputFile() { 1253 TimeTraceScope timeScope("Write output file"); 1254 openFile(); 1255 reportPendingUndefinedSymbols(); 1256 if (errorCount()) 1257 return; 1258 writeSections(); 1259 applyOptimizationHints(); 1260 buildFixupChains(); 1261 writeUuid(); 1262 writeCodeSignature(); 1263 1264 if (auto e = buffer->commit()) 1265 fatal("failed to write output '" + buffer->getPath() + 1266 "': " + toString(std::move(e))); 1267 } 1268 1269 template <class LP> void Writer::run() { 1270 treatSpecialUndefineds(); 1271 if (config->entry && needsBinding(config->entry)) 1272 in.stubs->addEntry(config->entry); 1273 1274 // Canonicalization of all pointers to InputSections should be handled by 1275 // these two scan* methods. I.e. from this point onward, for all live 1276 // InputSections, we should have `isec->canonical() == isec`. 1277 scanSymbols(); 1278 if (in.objcStubs->isNeeded()) 1279 in.objcStubs->setUp(); 1280 scanRelocations(); 1281 if (in.initOffsets->isNeeded()) 1282 in.initOffsets->setUp(); 1283 1284 // Do not proceed if there were undefined or duplicate symbols. 1285 reportPendingUndefinedSymbols(); 1286 reportPendingDuplicateSymbols(); 1287 if (errorCount()) 1288 return; 1289 1290 if (in.stubHelper && in.stubHelper->isNeeded()) 1291 in.stubHelper->setUp(); 1292 1293 if (in.objCImageInfo->isNeeded()) 1294 in.objCImageInfo->finalizeContents(); 1295 1296 // At this point, we should know exactly which output sections are needed, 1297 // courtesy of scanSymbols() and scanRelocations(). 1298 createOutputSections<LP>(); 1299 1300 // After this point, we create no new segments; HOWEVER, we might 1301 // yet create branch-range extension thunks for architectures whose 1302 // hardware call instructions have limited range, e.g., ARM(64). 1303 // The thunks are created as InputSections interspersed among 1304 // the ordinary __TEXT,_text InputSections. 1305 sortSegmentsAndSections(); 1306 createLoadCommands<LP>(); 1307 finalizeAddresses(); 1308 threadPool.async([&] { 1309 if (LLVM_ENABLE_THREADS && config->timeTraceEnabled) 1310 timeTraceProfilerInitialize(config->timeTraceGranularity, "writeMapFile"); 1311 writeMapFile(); 1312 if (LLVM_ENABLE_THREADS && config->timeTraceEnabled) 1313 timeTraceProfilerFinishThread(); 1314 }); 1315 finalizeLinkEditSegment(); 1316 writeOutputFile(); 1317 } 1318 1319 template <class LP> void macho::writeResult() { Writer().run<LP>(); } 1320 1321 void macho::resetWriter() { LCDylib::resetInstanceCount(); } 1322 1323 void macho::createSyntheticSections() { 1324 in.header = make<MachHeaderSection>(); 1325 if (config->dedupStrings) 1326 in.cStringSection = 1327 make<DeduplicatedCStringSection>(section_names::cString); 1328 else 1329 in.cStringSection = make<CStringSection>(section_names::cString); 1330 in.objcMethnameSection = 1331 make<DeduplicatedCStringSection>(section_names::objcMethname); 1332 in.wordLiteralSection = make<WordLiteralSection>(); 1333 if (config->emitChainedFixups) { 1334 in.chainedFixups = make<ChainedFixupsSection>(); 1335 } else { 1336 in.rebase = make<RebaseSection>(); 1337 in.binding = make<BindingSection>(); 1338 in.weakBinding = make<WeakBindingSection>(); 1339 in.lazyBinding = make<LazyBindingSection>(); 1340 in.lazyPointers = make<LazyPointerSection>(); 1341 in.stubHelper = make<StubHelperSection>(); 1342 } 1343 in.exports = make<ExportSection>(); 1344 in.got = make<GotSection>(); 1345 in.tlvPointers = make<TlvPointerSection>(); 1346 in.stubs = make<StubsSection>(); 1347 in.objcStubs = make<ObjCStubsSection>(); 1348 in.unwindInfo = makeUnwindInfoSection(); 1349 in.objCImageInfo = make<ObjCImageInfoSection>(); 1350 in.initOffsets = make<InitOffsetsSection>(); 1351 1352 // This section contains space for just a single word, and will be used by 1353 // dyld to cache an address to the image loader it uses. 1354 uint8_t *arr = bAlloc().Allocate<uint8_t>(target->wordSize); 1355 memset(arr, 0, target->wordSize); 1356 in.imageLoaderCache = makeSyntheticInputSection( 1357 segment_names::data, section_names::data, S_REGULAR, 1358 ArrayRef<uint8_t>{arr, target->wordSize}, 1359 /*align=*/target->wordSize); 1360 // References from dyld are not visible to us, so ensure this section is 1361 // always treated as live. 1362 in.imageLoaderCache->live = true; 1363 } 1364 1365 OutputSection *macho::firstTLVDataSection = nullptr; 1366 1367 template void macho::writeResult<LP64>(); 1368 template void macho::writeResult<ILP32>(); 1369