contrib/llvm/tools/lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

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