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
parsePackedVersion(StringRef str,uint32_t & result)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
parsePackedVersion(StringRef str,uint64_t & result)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
archFromCpuType(uint32_t cputype,uint32_t cpusubtype)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
archFromName(StringRef archName)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
nameFromArch(Arch arch)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
cpuTypeFromArch(Arch arch)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
cpuSubtypeFromArch(Arch arch)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
isThinObjectFile(StringRef path,Arch & arch)160 bool MachOLinkingContext::isThinObjectFile(StringRef path, Arch &arch) {
161 return mach_o::normalized::isThinObjectFile(path, arch);
162 }
163
sliceFromFatFile(MemoryBufferRef mb,uint32_t & offset,uint32_t & size)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
MachOLinkingContext()169 MachOLinkingContext::MachOLinkingContext() {}
170
~MachOLinkingContext()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
configure(HeaderFileType type,Arch arch,OS os,uint32_t minOSVersion,bool exportDynamicSymbols)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
getCPUType() const275 uint32_t MachOLinkingContext::getCPUType() const {
276 return cpuTypeFromArch(_arch);
277 }
278
getCPUSubType() const279 uint32_t MachOLinkingContext::getCPUSubType() const {
280 return cpuSubtypeFromArch(_arch);
281 }
282
is64Bit(Arch arch)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
isHostEndian(Arch arch)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
isBigEndian(Arch arch)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
is64Bit() const313 bool MachOLinkingContext::is64Bit() const {
314 return is64Bit(_arch);
315 }
316
outputTypeHasEntry() const317 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
needsStubsPass() const328 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
needsGOTPass() const340 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
needsCompactUnwindPass() const354 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
needsObjCPass() const365 bool MachOLinkingContext::needsObjCPass() const {
366 // ObjC pass is only needed if any of the inputs were ObjC.
367 return _objcConstraint != objc_unknown;
368 }
369
needsShimPass() const370 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
needsTLVPass() const385 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
binderSymbolName() const396 StringRef MachOLinkingContext::binderSymbolName() const {
397 return archHandler().stubInfo().binderSymbolName;
398 }
399
minOS(StringRef mac,StringRef iOS) const400 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
addEntryPointLoadCommand() const420 bool MachOLinkingContext::addEntryPointLoadCommand() const {
421 if ((_outputMachOType == MH_EXECUTE) && !_outputMachOTypeStatic) {
422 return minOS("10.8", "6.0");
423 }
424 return false;
425 }
426
addUnixThreadLoadCommand() const427 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
pathExists(StringRef path) const443 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
fileExists(StringRef path) const454 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
setSysLibRoots(const StringRefVector & paths)467 void MachOLinkingContext::setSysLibRoots(const StringRefVector &paths) {
468 _syslibRoots = paths;
469 }
470
addRpath(StringRef rpath)471 void MachOLinkingContext::addRpath(StringRef rpath) {
472 _rpaths.push_back(rpath);
473 }
474
addModifiedSearchDir(StringRef libPath,bool isSystemPath)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
addFrameworkSearchDir(StringRef fwPath,bool isSystemPath)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>
searchDirForLibrary(StringRef path,StringRef libName) const532 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>
searchLibrary(StringRef libName) const560 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>
findPathForFramework(StringRef fwName) const572 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
validateImpl()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
addPasses(PassManager & pm)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
writer() const652 Writer &MachOLinkingContext::writer() const {
653 if (!_writer)
654 _writer = createWriterMachO(*this);
655 return *_writer;
656 }
657
658 ErrorOr<std::unique_ptr<MemoryBuffer>>
getMemoryBuffer(StringRef path)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
loadIndirectDylib(StringRef path)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
findIndirectDylib(StringRef path)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
dylibCurrentVersion(StringRef installName) const727 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
dylibCompatVersion(StringRef installName) const735 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
createImplicitFiles(std::vector<std::unique_ptr<File>> & result)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
registerDylib(MachODylibFile * dylib,bool upward) const767 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
isUpwardDylib(StringRef installName) const782 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
archHandler() const790 ArchHandler &MachOLinkingContext::archHandler() const {
791 if (!_archHandler)
792 _archHandler = ArchHandler::create(_arch);
793 return *_archHandler;
794 }
795
addSectionAlignment(StringRef seg,StringRef sect,uint16_t align)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
addSectCreateSection(StringRef seg,StringRef sect,std::unique_ptr<MemoryBuffer> content)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
sectionAligned(StringRef seg,StringRef sect,uint16_t & align) const816 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
addExportSymbol(StringRef sym)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
exportSymbolNamed(StringRef sym) const852 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
demangle(StringRef symbolName) const865 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
addDependencyInfoHelper(llvm::raw_fd_ostream * DepInfo,char Opcode,StringRef Path)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
createDependencyFile(StringRef path)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
addInputFileDependency(StringRef path) const913 void MachOLinkingContext::addInputFileDependency(StringRef path) const {
914 addDependencyInfoHelper(_dependencyInfo.get(), 0x10, path);
915 }
916
addInputFileNotFound(StringRef path) const917 void MachOLinkingContext::addInputFileNotFound(StringRef path) const {
918 addDependencyInfoHelper(_dependencyInfo.get(), 0x11, path);
919 }
920
addOutputFileDependency(StringRef path) const921 void MachOLinkingContext::addOutputFileDependency(StringRef path) const {
922 addDependencyInfoHelper(_dependencyInfo.get(), 0x40, path);
923 }
924
appendOrderedSymbol(StringRef symbol,StringRef filename)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
findOrderOrdinal(const std::vector<OrderFileNode> & nodes,const DefinedAtom * atom,unsigned & ordinal)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
customAtomOrderer(const DefinedAtom * left,const DefinedAtom * right,bool & leftBeforeRight) const962 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
isLibrary(const std::unique_ptr<Node> & elem)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.
finalizeInputFiles()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
handleLoadedFile(File & file)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
1102