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