1//===- lib/ReaderWriter/MachO/MachOLinkingContext.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 "lld/Common/ErrorHandler.h" 10#include "lld/ReaderWriter/MachOLinkingContext.h" 11#include "ArchHandler.h" 12#include "File.h" 13#include "FlatNamespaceFile.h" 14#include "MachONormalizedFile.h" 15#include "MachOPasses.h" 16#include "SectCreateFile.h" 17#include "lld/Common/Driver.h" 18#include "lld/Core/ArchiveLibraryFile.h" 19#include "lld/Core/PassManager.h" 20#include "lld/Core/Reader.h" 21#include "lld/Core/Writer.h" 22#include "llvm/ADT/STLExtras.h" 23#include "llvm/ADT/StringExtras.h" 24#include "llvm/ADT/Triple.h" 25#include "llvm/BinaryFormat/MachO.h" 26#include "llvm/Demangle/Demangle.h" 27#include "llvm/Support/Debug.h" 28#include "llvm/Support/Errc.h" 29#include "llvm/Support/Host.h" 30#include "llvm/Support/Path.h" 31#include <algorithm> 32 33using lld::mach_o::ArchHandler; 34using lld::mach_o::MachOFile; 35using lld::mach_o::MachODylibFile; 36using namespace llvm::MachO; 37 38namespace lld { 39 40bool MachOLinkingContext::parsePackedVersion(StringRef str, uint32_t &result) { 41 result = 0; 42 43 if (str.empty()) 44 return false; 45 46 SmallVector<StringRef, 3> parts; 47 llvm::SplitString(str, parts, "."); 48 49 unsigned long long num; 50 if (llvm::getAsUnsignedInteger(parts[0], 10, num)) 51 return true; 52 if (num > 65535) 53 return true; 54 result = num << 16; 55 56 if (parts.size() > 1) { 57 if (llvm::getAsUnsignedInteger(parts[1], 10, num)) 58 return true; 59 if (num > 255) 60 return true; 61 result |= (num << 8); 62 } 63 64 if (parts.size() > 2) { 65 if (llvm::getAsUnsignedInteger(parts[2], 10, num)) 66 return true; 67 if (num > 255) 68 return true; 69 result |= num; 70 } 71 72 return false; 73} 74 75bool MachOLinkingContext::parsePackedVersion(StringRef str, uint64_t &result) { 76 result = 0; 77 78 if (str.empty()) 79 return false; 80 81 SmallVector<StringRef, 5> parts; 82 llvm::SplitString(str, parts, "."); 83 84 unsigned long long num; 85 if (llvm::getAsUnsignedInteger(parts[0], 10, num)) 86 return true; 87 if (num > 0xFFFFFF) 88 return true; 89 result = num << 40; 90 91 unsigned Shift = 30; 92 for (StringRef str : llvm::makeArrayRef(parts).slice(1)) { 93 if (llvm::getAsUnsignedInteger(str, 10, num)) 94 return true; 95 if (num > 0x3FF) 96 return true; 97 result |= (num << Shift); 98 Shift -= 10; 99 } 100 101 return false; 102} 103 104MachOLinkingContext::ArchInfo MachOLinkingContext::_s_archInfos[] = { 105 { "x86_64", arch_x86_64, true, CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL }, 106 { "i386", arch_x86, true, CPU_TYPE_I386, CPU_SUBTYPE_X86_ALL }, 107 { "ppc", arch_ppc, false, CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL }, 108 { "armv6", arch_armv6, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6 }, 109 { "armv7", arch_armv7, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7 }, 110 { "armv7s", arch_armv7s, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S }, 111 { "arm64", arch_arm64, true, CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL }, 112 { "", arch_unknown,false, 0, 0 } 113}; 114 115MachOLinkingContext::Arch 116MachOLinkingContext::archFromCpuType(uint32_t cputype, uint32_t cpusubtype) { 117 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 118 if ((info->cputype == cputype) && (info->cpusubtype == cpusubtype)) 119 return info->arch; 120 } 121 return arch_unknown; 122} 123 124MachOLinkingContext::Arch 125MachOLinkingContext::archFromName(StringRef archName) { 126 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 127 if (info->archName.equals(archName)) 128 return info->arch; 129 } 130 return arch_unknown; 131} 132 133StringRef MachOLinkingContext::nameFromArch(Arch arch) { 134 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 135 if (info->arch == arch) 136 return info->archName; 137 } 138 return "<unknown>"; 139} 140 141uint32_t MachOLinkingContext::cpuTypeFromArch(Arch arch) { 142 assert(arch != arch_unknown); 143 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 144 if (info->arch == arch) 145 return info->cputype; 146 } 147 llvm_unreachable("Unknown arch type"); 148} 149 150uint32_t MachOLinkingContext::cpuSubtypeFromArch(Arch arch) { 151 assert(arch != arch_unknown); 152 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 153 if (info->arch == arch) 154 return info->cpusubtype; 155 } 156 llvm_unreachable("Unknown arch type"); 157} 158 159bool MachOLinkingContext::isThinObjectFile(StringRef path, Arch &arch) { 160 return mach_o::normalized::isThinObjectFile(path, arch); 161} 162 163bool MachOLinkingContext::sliceFromFatFile(MemoryBufferRef mb, uint32_t &offset, 164 uint32_t &size) { 165 return mach_o::normalized::sliceFromFatFile(mb, _arch, offset, size); 166} 167 168MachOLinkingContext::MachOLinkingContext() {} 169 170MachOLinkingContext::~MachOLinkingContext() { 171 // Atoms are allocated on BumpPtrAllocator's on File's. 172 // As we transfer atoms from one file to another, we need to clear all of the 173 // atoms before we remove any of the BumpPtrAllocator's. 174 auto &nodes = getNodes(); 175 for (unsigned i = 0, e = nodes.size(); i != e; ++i) { 176 FileNode *node = dyn_cast<FileNode>(nodes[i].get()); 177 if (!node) 178 continue; 179 File *file = node->getFile(); 180 file->clearAtoms(); 181 } 182} 183 184void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os, 185 uint32_t minOSVersion, 186 bool exportDynamicSymbols) { 187 _outputMachOType = type; 188 _arch = arch; 189 _os = os; 190 _osMinVersion = minOSVersion; 191 192 // If min OS not specified on command line, use reasonable defaults. 193 // Note that we only do sensible defaults when emitting something other than 194 // object and preload. 195 if (_outputMachOType != llvm::MachO::MH_OBJECT && 196 _outputMachOType != llvm::MachO::MH_PRELOAD) { 197 if (minOSVersion == 0) { 198 switch (_arch) { 199 case arch_x86_64: 200 case arch_x86: 201 parsePackedVersion("10.8", _osMinVersion); 202 _os = MachOLinkingContext::OS::macOSX; 203 break; 204 case arch_armv6: 205 case arch_armv7: 206 case arch_armv7s: 207 case arch_arm64: 208 parsePackedVersion("7.0", _osMinVersion); 209 _os = MachOLinkingContext::OS::iOS; 210 break; 211 default: 212 break; 213 } 214 } 215 } 216 217 switch (_outputMachOType) { 218 case llvm::MachO::MH_EXECUTE: 219 // If targeting newer OS, use _main 220 if (minOS("10.8", "6.0")) { 221 _entrySymbolName = "_main"; 222 } else { 223 // If targeting older OS, use start (in crt1.o) 224 _entrySymbolName = "start"; 225 } 226 227 // __PAGEZERO defaults to 4GB on 64-bit (except for PP64 which lld does not 228 // support) and 4KB on 32-bit. 229 if (is64Bit(_arch)) { 230 _pageZeroSize = 0x100000000; 231 } else { 232 _pageZeroSize = 0x1000; 233 } 234 235 // Initial base address is __PAGEZERO size. 236 _baseAddress = _pageZeroSize; 237 238 // Make PIE by default when targetting newer OSs. 239 switch (os) { 240 case OS::macOSX: 241 if (minOSVersion >= 0x000A0700) // MacOSX 10.7 242 _pie = true; 243 break; 244 case OS::iOS: 245 if (minOSVersion >= 0x00040300) // iOS 4.3 246 _pie = true; 247 break; 248 case OS::iOS_simulator: 249 _pie = true; 250 break; 251 case OS::unknown: 252 break; 253 } 254 setGlobalsAreDeadStripRoots(exportDynamicSymbols); 255 break; 256 case llvm::MachO::MH_DYLIB: 257 setGlobalsAreDeadStripRoots(exportDynamicSymbols); 258 break; 259 case llvm::MachO::MH_BUNDLE: 260 break; 261 case llvm::MachO::MH_OBJECT: 262 _printRemainingUndefines = false; 263 _allowRemainingUndefines = true; 264 break; 265 default: 266 break; 267 } 268 269 // Set default segment page sizes based on arch. 270 if (arch == arch_arm64) 271 _pageSize = 4*4096; 272} 273 274uint32_t MachOLinkingContext::getCPUType() const { 275 return cpuTypeFromArch(_arch); 276} 277 278uint32_t MachOLinkingContext::getCPUSubType() const { 279 return cpuSubtypeFromArch(_arch); 280} 281 282bool MachOLinkingContext::is64Bit(Arch arch) { 283 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 284 if (info->arch == arch) { 285 return (info->cputype & CPU_ARCH_ABI64); 286 } 287 } 288 // unknown archs are not 64-bit. 289 return false; 290} 291 292bool MachOLinkingContext::isHostEndian(Arch arch) { 293 assert(arch != arch_unknown); 294 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 295 if (info->arch == arch) { 296 return (info->littleEndian == llvm::sys::IsLittleEndianHost); 297 } 298 } 299 llvm_unreachable("Unknown arch type"); 300} 301 302bool MachOLinkingContext::isBigEndian(Arch arch) { 303 assert(arch != arch_unknown); 304 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) { 305 if (info->arch == arch) { 306 return ! info->littleEndian; 307 } 308 } 309 llvm_unreachable("Unknown arch type"); 310} 311 312bool MachOLinkingContext::is64Bit() const { 313 return is64Bit(_arch); 314} 315 316bool MachOLinkingContext::outputTypeHasEntry() const { 317 switch (_outputMachOType) { 318 case MH_EXECUTE: 319 case MH_DYLINKER: 320 case MH_PRELOAD: 321 return true; 322 default: 323 return false; 324 } 325} 326 327bool MachOLinkingContext::needsStubsPass() const { 328 switch (_outputMachOType) { 329 case MH_EXECUTE: 330 return !_outputMachOTypeStatic; 331 case MH_DYLIB: 332 case MH_BUNDLE: 333 return true; 334 default: 335 return false; 336 } 337} 338 339bool MachOLinkingContext::needsGOTPass() const { 340 // GOT pass not used in -r mode. 341 if (_outputMachOType == MH_OBJECT) 342 return false; 343 // Only some arches use GOT pass. 344 switch (_arch) { 345 case arch_x86_64: 346 case arch_arm64: 347 return true; 348 default: 349 return false; 350 } 351} 352 353bool MachOLinkingContext::needsCompactUnwindPass() const { 354 switch (_outputMachOType) { 355 case MH_EXECUTE: 356 case MH_DYLIB: 357 case MH_BUNDLE: 358 return archHandler().needsCompactUnwind(); 359 default: 360 return false; 361 } 362} 363 364bool MachOLinkingContext::needsObjCPass() const { 365 // ObjC pass is only needed if any of the inputs were ObjC. 366 return _objcConstraint != objc_unknown; 367} 368 369bool MachOLinkingContext::needsShimPass() const { 370 // Shim pass only used in final executables. 371 if (_outputMachOType == MH_OBJECT) 372 return false; 373 // Only 32-bit arm arches use Shim pass. 374 switch (_arch) { 375 case arch_armv6: 376 case arch_armv7: 377 case arch_armv7s: 378 return true; 379 default: 380 return false; 381 } 382} 383 384bool MachOLinkingContext::needsTLVPass() const { 385 switch (_outputMachOType) { 386 case MH_BUNDLE: 387 case MH_EXECUTE: 388 case MH_DYLIB: 389 return true; 390 default: 391 return false; 392 } 393} 394 395StringRef MachOLinkingContext::binderSymbolName() const { 396 return archHandler().stubInfo().binderSymbolName; 397} 398 399bool MachOLinkingContext::minOS(StringRef mac, StringRef iOS) const { 400 uint32_t parsedVersion; 401 switch (_os) { 402 case OS::macOSX: 403 if (parsePackedVersion(mac, parsedVersion)) 404 return false; 405 return _osMinVersion >= parsedVersion; 406 case OS::iOS: 407 case OS::iOS_simulator: 408 if (parsePackedVersion(iOS, parsedVersion)) 409 return false; 410 return _osMinVersion >= parsedVersion; 411 case OS::unknown: 412 // If we don't know the target, then assume that we don't meet the min OS. 413 // This matches the ld64 behaviour 414 return false; 415 } 416 llvm_unreachable("invalid OS enum"); 417} 418 419bool MachOLinkingContext::addEntryPointLoadCommand() const { 420 if ((_outputMachOType == MH_EXECUTE) && !_outputMachOTypeStatic) { 421 return minOS("10.8", "6.0"); 422 } 423 return false; 424} 425 426bool MachOLinkingContext::addUnixThreadLoadCommand() const { 427 switch (_outputMachOType) { 428 case MH_EXECUTE: 429 if (_outputMachOTypeStatic) 430 return true; 431 else 432 return !minOS("10.8", "6.0"); 433 break; 434 case MH_DYLINKER: 435 case MH_PRELOAD: 436 return true; 437 default: 438 return false; 439 } 440} 441 442bool MachOLinkingContext::pathExists(StringRef path) const { 443 if (!_testingFileUsage) 444 return llvm::sys::fs::exists(path.str()); 445 446 // Otherwise, we're in test mode: only files explicitly provided on the 447 // command-line exist. 448 std::string key = path.str(); 449 std::replace(key.begin(), key.end(), '\\', '/'); 450 return _existingPaths.find(key) != _existingPaths.end(); 451} 452 453bool MachOLinkingContext::fileExists(StringRef path) const { 454 bool found = pathExists(path); 455 // Log search misses. 456 if (!found) 457 addInputFileNotFound(path); 458 459 // When testing, file is never opened, so logging is done here. 460 if (_testingFileUsage && found) 461 addInputFileDependency(path); 462 463 return found; 464} 465 466void MachOLinkingContext::setSysLibRoots(const StringRefVector &paths) { 467 _syslibRoots = paths; 468} 469 470void MachOLinkingContext::addRpath(StringRef rpath) { 471 _rpaths.push_back(rpath); 472} 473 474void MachOLinkingContext::addModifiedSearchDir(StringRef libPath, 475 bool isSystemPath) { 476 bool addedModifiedPath = false; 477 478 // -syslibroot only applies to absolute paths. 479 if (libPath.startswith("/")) { 480 for (auto syslibRoot : _syslibRoots) { 481 SmallString<256> path(syslibRoot); 482 llvm::sys::path::append(path, libPath); 483 if (pathExists(path)) { 484 _searchDirs.push_back(path.str().copy(_allocator)); 485 addedModifiedPath = true; 486 } 487 } 488 } 489 490 if (addedModifiedPath) 491 return; 492 493 // Finally, if only one -syslibroot is given, system paths which aren't in it 494 // get suppressed. 495 if (_syslibRoots.size() != 1 || !isSystemPath) { 496 if (pathExists(libPath)) { 497 _searchDirs.push_back(libPath); 498 } 499 } 500} 501 502void MachOLinkingContext::addFrameworkSearchDir(StringRef fwPath, 503 bool isSystemPath) { 504 bool pathAdded = false; 505 506 // -syslibroot only used with to absolute framework search paths. 507 if (fwPath.startswith("/")) { 508 for (auto syslibRoot : _syslibRoots) { 509 SmallString<256> path(syslibRoot); 510 llvm::sys::path::append(path, fwPath); 511 if (pathExists(path)) { 512 _frameworkDirs.push_back(path.str().copy(_allocator)); 513 pathAdded = true; 514 } 515 } 516 } 517 // If fwPath found in any -syslibroot, then done. 518 if (pathAdded) 519 return; 520 521 // If only one -syslibroot, system paths not in that SDK are suppressed. 522 if (isSystemPath && (_syslibRoots.size() == 1)) 523 return; 524 525 // Only use raw fwPath if that directory exists. 526 if (pathExists(fwPath)) 527 _frameworkDirs.push_back(fwPath); 528} 529 530llvm::Optional<StringRef> 531MachOLinkingContext::searchDirForLibrary(StringRef path, 532 StringRef libName) const { 533 SmallString<256> fullPath; 534 if (libName.endswith(".o")) { 535 // A request ending in .o is special: just search for the file directly. 536 fullPath.assign(path); 537 llvm::sys::path::append(fullPath, libName); 538 if (fileExists(fullPath)) 539 return fullPath.str().copy(_allocator); 540 return llvm::None; 541 } 542 543 // Search for dynamic library 544 fullPath.assign(path); 545 llvm::sys::path::append(fullPath, Twine("lib") + libName + ".dylib"); 546 if (fileExists(fullPath)) 547 return fullPath.str().copy(_allocator); 548 549 // If not, try for a static library 550 fullPath.assign(path); 551 llvm::sys::path::append(fullPath, Twine("lib") + libName + ".a"); 552 if (fileExists(fullPath)) 553 return fullPath.str().copy(_allocator); 554 555 return llvm::None; 556} 557 558llvm::Optional<StringRef> 559MachOLinkingContext::searchLibrary(StringRef libName) const { 560 SmallString<256> path; 561 for (StringRef dir : searchDirs()) { 562 llvm::Optional<StringRef> searchDir = searchDirForLibrary(dir, libName); 563 if (searchDir) 564 return searchDir; 565 } 566 567 return llvm::None; 568} 569 570llvm::Optional<StringRef> 571MachOLinkingContext::findPathForFramework(StringRef fwName) const{ 572 SmallString<256> fullPath; 573 for (StringRef dir : frameworkDirs()) { 574 fullPath.assign(dir); 575 llvm::sys::path::append(fullPath, Twine(fwName) + ".framework", fwName); 576 if (fileExists(fullPath)) 577 return fullPath.str().copy(_allocator); 578 } 579 580 return llvm::None; 581} 582 583bool MachOLinkingContext::validateImpl() { 584 // TODO: if -arch not specified, look at arch of first .o file. 585 586 if (_currentVersion && _outputMachOType != MH_DYLIB) { 587 error("-current_version can only be used with dylibs"); 588 return false; 589 } 590 591 if (_compatibilityVersion && _outputMachOType != MH_DYLIB) { 592 error("-compatibility_version can only be used with dylibs"); 593 return false; 594 } 595 596 if (_deadStrippableDylib && _outputMachOType != MH_DYLIB) { 597 error("-mark_dead_strippable_dylib can only be used with dylibs"); 598 return false; 599 } 600 601 if (!_bundleLoader.empty() && outputMachOType() != MH_BUNDLE) { 602 error("-bundle_loader can only be used with Mach-O bundles"); 603 return false; 604 } 605 606 // If -exported_symbols_list used, all exported symbols must be defined. 607 if (_exportMode == ExportMode::whiteList) { 608 for (const auto &symbol : _exportedSymbols) 609 addInitialUndefinedSymbol(symbol.getKey()); 610 } 611 612 // If -dead_strip, set up initial live symbols. 613 if (deadStrip()) { 614 // Entry point is live. 615 if (outputTypeHasEntry()) 616 addDeadStripRoot(entrySymbolName()); 617 // Lazy binding helper is live. 618 if (needsStubsPass()) 619 addDeadStripRoot(binderSymbolName()); 620 // If using -exported_symbols_list, make all exported symbols live. 621 if (_exportMode == ExportMode::whiteList) { 622 setGlobalsAreDeadStripRoots(false); 623 for (const auto &symbol : _exportedSymbols) 624 addDeadStripRoot(symbol.getKey()); 625 } 626 } 627 628 addOutputFileDependency(outputPath()); 629 630 return true; 631} 632 633void MachOLinkingContext::addPasses(PassManager &pm) { 634 // objc pass should be before layout pass. Otherwise test cases may contain 635 // no atoms which confuses the layout pass. 636 if (needsObjCPass()) 637 mach_o::addObjCPass(pm, *this); 638 mach_o::addLayoutPass(pm, *this); 639 if (needsStubsPass()) 640 mach_o::addStubsPass(pm, *this); 641 if (needsCompactUnwindPass()) 642 mach_o::addCompactUnwindPass(pm, *this); 643 if (needsGOTPass()) 644 mach_o::addGOTPass(pm, *this); 645 if (needsTLVPass()) 646 mach_o::addTLVPass(pm, *this); 647 if (needsShimPass()) 648 mach_o::addShimPass(pm, *this); // Shim pass must run after stubs pass. 649} 650 651Writer &MachOLinkingContext::writer() const { 652 if (!_writer) 653 _writer = createWriterMachO(*this); 654 return *_writer; 655} 656 657ErrorOr<std::unique_ptr<MemoryBuffer>> 658MachOLinkingContext::getMemoryBuffer(StringRef path) { 659 addInputFileDependency(path); 660 661 ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = 662 MemoryBuffer::getFileOrSTDIN(path); 663 if (std::error_code ec = mbOrErr.getError()) 664 return ec; 665 std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get()); 666 667 // If buffer contains a fat file, find required arch in fat buffer 668 // and switch buffer to point to just that required slice. 669 uint32_t offset; 670 uint32_t size; 671 if (sliceFromFatFile(mb->getMemBufferRef(), offset, size)) 672 return MemoryBuffer::getFileSlice(path, size, offset); 673 return std::move(mb); 674} 675 676MachODylibFile* MachOLinkingContext::loadIndirectDylib(StringRef path) { 677 ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = getMemoryBuffer(path); 678 if (mbOrErr.getError()) 679 return nullptr; 680 681 ErrorOr<std::unique_ptr<File>> fileOrErr = 682 registry().loadFile(std::move(mbOrErr.get())); 683 if (!fileOrErr) 684 return nullptr; 685 std::unique_ptr<File> &file = fileOrErr.get(); 686 file->parse(); 687 MachODylibFile *result = reinterpret_cast<MachODylibFile *>(file.get()); 688 // Node object now owned by _indirectDylibs vector. 689 _indirectDylibs.push_back(std::move(file)); 690 return result; 691} 692 693MachODylibFile* MachOLinkingContext::findIndirectDylib(StringRef path) { 694 // See if already loaded. 695 auto pos = _pathToDylibMap.find(path); 696 if (pos != _pathToDylibMap.end()) 697 return pos->second; 698 699 // Search -L paths if of the form "libXXX.dylib" 700 std::pair<StringRef, StringRef> split = path.rsplit('/'); 701 StringRef leafName = split.second; 702 if (leafName.startswith("lib") && leafName.endswith(".dylib")) { 703 // FIXME: Need to enhance searchLibrary() to only look for .dylib 704 auto libPath = searchLibrary(leafName); 705 if (libPath) 706 return loadIndirectDylib(libPath.getValue()); 707 } 708 709 // Try full path with sysroot. 710 for (StringRef sysPath : _syslibRoots) { 711 SmallString<256> fullPath; 712 fullPath.assign(sysPath); 713 llvm::sys::path::append(fullPath, path); 714 if (pathExists(fullPath)) 715 return loadIndirectDylib(fullPath); 716 } 717 718 // Try full path. 719 if (pathExists(path)) { 720 return loadIndirectDylib(path); 721 } 722 723 return nullptr; 724} 725 726uint32_t MachOLinkingContext::dylibCurrentVersion(StringRef installName) const { 727 auto pos = _pathToDylibMap.find(installName); 728 if (pos != _pathToDylibMap.end()) 729 return pos->second->currentVersion(); 730 else 731 return 0x10000; // 1.0 732} 733 734uint32_t MachOLinkingContext::dylibCompatVersion(StringRef installName) const { 735 auto pos = _pathToDylibMap.find(installName); 736 if (pos != _pathToDylibMap.end()) 737 return pos->second->compatVersion(); 738 else 739 return 0x10000; // 1.0 740} 741 742void MachOLinkingContext::createImplicitFiles( 743 std::vector<std::unique_ptr<File> > &result) { 744 // Add indirect dylibs by asking each linked dylib to add its indirects. 745 // Iterate until no more dylibs get loaded. 746 size_t dylibCount = 0; 747 while (dylibCount != _allDylibs.size()) { 748 dylibCount = _allDylibs.size(); 749 for (MachODylibFile *dylib : _allDylibs) { 750 dylib->loadReExportedDylibs([this] (StringRef path) -> MachODylibFile* { 751 return findIndirectDylib(path); }); 752 } 753 } 754 755 // Let writer add output type specific extras. 756 writer().createImplicitFiles(result); 757 758 // If undefinedMode is != error, add a FlatNamespaceFile instance. This will 759 // provide a SharedLibraryAtom for symbols that aren't defined elsewhere. 760 if (undefinedMode() != UndefinedMode::error) { 761 result.emplace_back(new mach_o::FlatNamespaceFile(*this)); 762 _flatNamespaceFile = result.back().get(); 763 } 764} 765 766void MachOLinkingContext::registerDylib(MachODylibFile *dylib, 767 bool upward) const { 768 std::lock_guard<std::mutex> lock(_dylibsMutex); 769 770 if (!llvm::count(_allDylibs, dylib)) 771 _allDylibs.push_back(dylib); 772 _pathToDylibMap[dylib->installName()] = dylib; 773 // If path is different than install name, register path too. 774 if (!dylib->path().equals(dylib->installName())) 775 _pathToDylibMap[dylib->path()] = dylib; 776 if (upward) 777 _upwardDylibs.insert(dylib); 778} 779 780bool MachOLinkingContext::isUpwardDylib(StringRef installName) const { 781 for (MachODylibFile *dylib : _upwardDylibs) { 782 if (dylib->installName().equals(installName)) 783 return true; 784 } 785 return false; 786} 787 788ArchHandler &MachOLinkingContext::archHandler() const { 789 if (!_archHandler) 790 _archHandler = ArchHandler::create(_arch); 791 return *_archHandler; 792} 793 794void MachOLinkingContext::addSectionAlignment(StringRef seg, StringRef sect, 795 uint16_t align) { 796 SectionAlign entry = { seg, sect, align }; 797 _sectAligns.push_back(entry); 798} 799 800void MachOLinkingContext::addSectCreateSection( 801 StringRef seg, StringRef sect, 802 std::unique_ptr<MemoryBuffer> content) { 803 804 if (!_sectCreateFile) { 805 auto sectCreateFile = std::make_unique<mach_o::SectCreateFile>(); 806 _sectCreateFile = sectCreateFile.get(); 807 getNodes().push_back(std::make_unique<FileNode>(std::move(sectCreateFile))); 808 } 809 810 assert(_sectCreateFile && "sectcreate file does not exist."); 811 _sectCreateFile->addSection(seg, sect, std::move(content)); 812} 813 814bool MachOLinkingContext::sectionAligned(StringRef seg, StringRef sect, 815 uint16_t &align) const { 816 for (const SectionAlign &entry : _sectAligns) { 817 if (seg.equals(entry.segmentName) && sect.equals(entry.sectionName)) { 818 align = entry.align; 819 return true; 820 } 821 } 822 return false; 823} 824 825void MachOLinkingContext::addExportSymbol(StringRef sym) { 826 // Support old crufty export lists with bogus entries. 827 if (sym.endswith(".eh") || sym.startswith(".objc_category_name_")) { 828 llvm::errs() << "warning: ignoring " << sym << " in export list\n"; 829 return; 830 } 831 // Only i386 MacOSX uses old ABI, so don't change those. 832 if ((_os != OS::macOSX) || (_arch != arch_x86)) { 833 // ObjC has two different ABIs. Be nice and allow one export list work for 834 // both ABIs by renaming symbols. 835 if (sym.startswith(".objc_class_name_")) { 836 std::string abi2className("_OBJC_CLASS_$_"); 837 abi2className += sym.substr(17); 838 _exportedSymbols.insert(copy(abi2className)); 839 std::string abi2metaclassName("_OBJC_METACLASS_$_"); 840 abi2metaclassName += sym.substr(17); 841 _exportedSymbols.insert(copy(abi2metaclassName)); 842 return; 843 } 844 } 845 846 // FIXME: Support wildcards. 847 _exportedSymbols.insert(sym); 848} 849 850bool MachOLinkingContext::exportSymbolNamed(StringRef sym) const { 851 switch (_exportMode) { 852 case ExportMode::globals: 853 llvm_unreachable("exportSymbolNamed() should not be called in this mode"); 854 break; 855 case ExportMode::whiteList: 856 return _exportedSymbols.count(sym); 857 case ExportMode::blackList: 858 return !_exportedSymbols.count(sym); 859 } 860 llvm_unreachable("_exportMode unknown enum value"); 861} 862 863std::string MachOLinkingContext::demangle(StringRef symbolName) const { 864 // Only try to demangle symbols if -demangle on command line 865 if (!demangleSymbols()) 866 return symbolName; 867 868 // Only try to demangle symbols that look like C++ symbols 869 if (!symbolName.startswith("__Z")) 870 return symbolName; 871 872 SmallString<256> symBuff; 873 StringRef nullTermSym = Twine(symbolName).toNullTerminatedStringRef(symBuff); 874 // Mach-O has extra leading underscore that needs to be removed. 875 const char *cstr = nullTermSym.data() + 1; 876 int status; 877 char *demangled = llvm::itaniumDemangle(cstr, nullptr, nullptr, &status); 878 if (demangled) { 879 std::string result(demangled); 880 // __cxa_demangle() always uses a malloc'ed buffer to return the result. 881 free(demangled); 882 return result; 883 } 884 885 return symbolName; 886} 887 888static void addDependencyInfoHelper(llvm::raw_fd_ostream *DepInfo, 889 char Opcode, StringRef Path) { 890 if (!DepInfo) 891 return; 892 893 *DepInfo << Opcode; 894 *DepInfo << Path; 895 *DepInfo << '\0'; 896} 897 898std::error_code MachOLinkingContext::createDependencyFile(StringRef path) { 899 std::error_code ec; 900 _dependencyInfo = std::unique_ptr<llvm::raw_fd_ostream>( 901 new llvm::raw_fd_ostream(path, ec, llvm::sys::fs::OF_None)); 902 if (ec) { 903 _dependencyInfo.reset(); 904 return ec; 905 } 906 907 addDependencyInfoHelper(_dependencyInfo.get(), 0x00, "lld" /*FIXME*/); 908 return std::error_code(); 909} 910 911void MachOLinkingContext::addInputFileDependency(StringRef path) const { 912 addDependencyInfoHelper(_dependencyInfo.get(), 0x10, path); 913} 914 915void MachOLinkingContext::addInputFileNotFound(StringRef path) const { 916 addDependencyInfoHelper(_dependencyInfo.get(), 0x11, path); 917} 918 919void MachOLinkingContext::addOutputFileDependency(StringRef path) const { 920 addDependencyInfoHelper(_dependencyInfo.get(), 0x40, path); 921} 922 923void MachOLinkingContext::appendOrderedSymbol(StringRef symbol, 924 StringRef filename) { 925 // To support sorting static functions which may have the same name in 926 // multiple .o files, _orderFiles maps the symbol name to a vector 927 // of OrderFileNode each of which can specify a file prefix. 928 OrderFileNode info; 929 if (!filename.empty()) 930 info.fileFilter = copy(filename); 931 info.order = _orderFileEntries++; 932 _orderFiles[symbol].push_back(info); 933} 934 935bool 936MachOLinkingContext::findOrderOrdinal(const std::vector<OrderFileNode> &nodes, 937 const DefinedAtom *atom, 938 unsigned &ordinal) { 939 const File *objFile = &atom->file(); 940 assert(objFile); 941 StringRef objName = objFile->path(); 942 std::pair<StringRef, StringRef> dirAndLeaf = objName.rsplit('/'); 943 if (!dirAndLeaf.second.empty()) 944 objName = dirAndLeaf.second; 945 for (const OrderFileNode &info : nodes) { 946 if (info.fileFilter.empty()) { 947 // Have unprefixed symbol name in order file that matches this atom. 948 ordinal = info.order; 949 return true; 950 } 951 if (info.fileFilter.equals(objName)) { 952 // Have prefixed symbol name in order file that matches atom's path. 953 ordinal = info.order; 954 return true; 955 } 956 } 957 return false; 958} 959 960bool MachOLinkingContext::customAtomOrderer(const DefinedAtom *left, 961 const DefinedAtom *right, 962 bool &leftBeforeRight) const { 963 // No custom sorting if no order file entries. 964 if (!_orderFileEntries) 965 return false; 966 967 // Order files can only order named atoms. 968 StringRef leftName = left->name(); 969 StringRef rightName = right->name(); 970 if (leftName.empty() || rightName.empty()) 971 return false; 972 973 // If neither is in order file list, no custom sorter. 974 auto leftPos = _orderFiles.find(leftName); 975 auto rightPos = _orderFiles.find(rightName); 976 bool leftIsOrdered = (leftPos != _orderFiles.end()); 977 bool rightIsOrdered = (rightPos != _orderFiles.end()); 978 if (!leftIsOrdered && !rightIsOrdered) 979 return false; 980 981 // There could be multiple symbols with same name but different file prefixes. 982 unsigned leftOrder; 983 unsigned rightOrder; 984 bool foundLeft = 985 leftIsOrdered && findOrderOrdinal(leftPos->getValue(), left, leftOrder); 986 bool foundRight = rightIsOrdered && 987 findOrderOrdinal(rightPos->getValue(), right, rightOrder); 988 if (!foundLeft && !foundRight) 989 return false; 990 991 // If only one is in order file list, ordered one goes first. 992 if (foundLeft != foundRight) 993 leftBeforeRight = foundLeft; 994 else 995 leftBeforeRight = (leftOrder < rightOrder); 996 997 return true; 998} 999 1000static bool isLibrary(const std::unique_ptr<Node> &elem) { 1001 if (FileNode *node = dyn_cast<FileNode>(const_cast<Node *>(elem.get()))) { 1002 File *file = node->getFile(); 1003 return isa<SharedLibraryFile>(file) || isa<ArchiveLibraryFile>(file); 1004 } 1005 return false; 1006} 1007 1008// The darwin linker processes input files in two phases. The first phase 1009// links in all object (.o) files in command line order. The second phase 1010// links in libraries in command line order. 1011// In this function we reorder the input files so that all the object files 1012// comes before any library file. We also make a group for the library files 1013// so that the Resolver will reiterate over the libraries as long as we find 1014// new undefines from libraries. 1015void MachOLinkingContext::finalizeInputFiles() { 1016 std::vector<std::unique_ptr<Node>> &elements = getNodes(); 1017 llvm::stable_sort(elements, [](const std::unique_ptr<Node> &a, 1018 const std::unique_ptr<Node> &b) { 1019 return !isLibrary(a) && isLibrary(b); 1020 }); 1021 size_t numLibs = std::count_if(elements.begin(), elements.end(), isLibrary); 1022 elements.push_back(std::make_unique<GroupEnd>(numLibs)); 1023} 1024 1025llvm::Error MachOLinkingContext::handleLoadedFile(File &file) { 1026 auto *machoFile = dyn_cast<MachOFile>(&file); 1027 if (!machoFile) 1028 return llvm::Error::success(); 1029 1030 // Check that the arch of the context matches that of the file. 1031 // Also set the arch of the context if it didn't have one. 1032 if (_arch == arch_unknown) { 1033 _arch = machoFile->arch(); 1034 } else if (machoFile->arch() != arch_unknown && machoFile->arch() != _arch) { 1035 // Archs are different. 1036 return llvm::make_error<GenericError>(file.path() + 1037 Twine(" cannot be linked due to incompatible architecture")); 1038 } 1039 1040 // Check that the OS of the context matches that of the file. 1041 // Also set the OS of the context if it didn't have one. 1042 if (_os == OS::unknown) { 1043 _os = machoFile->OS(); 1044 } else if (machoFile->OS() != OS::unknown && machoFile->OS() != _os) { 1045 // OSes are different. 1046 return llvm::make_error<GenericError>(file.path() + 1047 Twine(" cannot be linked due to incompatible operating systems")); 1048 } 1049 1050 // Check that if the objc info exists, that it is compatible with the target 1051 // OS. 1052 switch (machoFile->objcConstraint()) { 1053 case objc_unknown: 1054 // The file is not compiled with objc, so skip the checks. 1055 break; 1056 case objc_gc_only: 1057 case objc_supports_gc: 1058 llvm_unreachable("GC support should already have thrown an error"); 1059 case objc_retainReleaseForSimulator: 1060 // The file is built with simulator objc, so make sure that the context 1061 // is also building with simulator support. 1062 if (_os != OS::iOS_simulator) 1063 return llvm::make_error<GenericError>(file.path() + 1064 Twine(" cannot be linked. It contains ObjC built for the simulator" 1065 " while we are linking a non-simulator target")); 1066 assert((_objcConstraint == objc_unknown || 1067 _objcConstraint == objc_retainReleaseForSimulator) && 1068 "Must be linking with retain/release for the simulator"); 1069 _objcConstraint = objc_retainReleaseForSimulator; 1070 break; 1071 case objc_retainRelease: 1072 // The file is built without simulator objc, so make sure that the 1073 // context is also building without simulator support. 1074 if (_os == OS::iOS_simulator) 1075 return llvm::make_error<GenericError>(file.path() + 1076 Twine(" cannot be linked. It contains ObjC built for a non-simulator" 1077 " target while we are linking a simulator target")); 1078 assert((_objcConstraint == objc_unknown || 1079 _objcConstraint == objc_retainRelease) && 1080 "Must be linking with retain/release for a non-simulator target"); 1081 _objcConstraint = objc_retainRelease; 1082 break; 1083 } 1084 1085 // Check that the swift version of the context matches that of the file. 1086 // Also set the swift version of the context if it didn't have one. 1087 if (!_swiftVersion) { 1088 _swiftVersion = machoFile->swiftVersion(); 1089 } else if (machoFile->swiftVersion() && 1090 machoFile->swiftVersion() != _swiftVersion) { 1091 // Swift versions are different. 1092 return llvm::make_error<GenericError>("different swift versions"); 1093 } 1094 1095 return llvm::Error::success(); 1096} 1097 1098} // end namespace lld 1099