blob: 1c97c5a39d3ff3aedfd2c40c509acda22d57627c [file] [log] [blame]
Rui Ueyama0ca149f2013-08-06 22:31:59 +00001//===- 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/ReaderWriter/MachOLinkingContext.h"
Nick Kledzik2458bec2014-07-16 19:49:02 +000011#include "ArchHandler.h"
Nick Kledzik8fc67fb2014-08-13 23:55:41 +000012#include "File.h"
Lang Hames5c692002015-09-28 20:25:14 +000013#include "FlatNamespaceFile.h"
Nick Kledzik635f9c72014-09-04 20:08:30 +000014#include "MachONormalizedFile.h"
Nick Kledzik2458bec2014-07-16 19:49:02 +000015#include "MachOPasses.h"
Lang Hamesb1b67f42015-10-24 08:20:51 +000016#include "SectCreateFile.h"
Rui Ueyamadf230b22015-01-15 04:34:31 +000017#include "lld/Core/ArchiveLibraryFile.h"
Rui Ueyama0ca149f2013-08-06 22:31:59 +000018#include "lld/Core/PassManager.h"
Greg Fitzgerald4b6a7e32015-01-21 22:54:56 +000019#include "lld/Core/Reader.h"
20#include "lld/Core/Writer.h"
Rui Ueyamadf230b22015-01-15 04:34:31 +000021#include "lld/Driver/Driver.h"
Benjamin Kramer06a42af2015-03-02 00:48:06 +000022#include "llvm/ADT/STLExtras.h"
Rui Ueyama0ca149f2013-08-06 22:31:59 +000023#include "llvm/ADT/StringExtras.h"
24#include "llvm/ADT/Triple.h"
Nick Kledzikbe43d7e2014-09-30 23:15:39 +000025#include "llvm/Config/config.h"
Rui Ueyama00eb2572014-12-10 00:33:00 +000026#include "llvm/Support/Debug.h"
Chandler Carruth89642a72015-01-14 11:26:52 +000027#include "llvm/Support/Errc.h"
Nick Kledzike34182f2013-11-06 21:36:55 +000028#include "llvm/Support/Host.h"
Nick Kledzik473933b2013-09-27 22:50:00 +000029#include "llvm/Support/MachO.h"
Tim Northover77d82202014-07-10 11:21:06 +000030#include "llvm/Support/Path.h"
Rui Ueyama57a29532014-08-06 19:37:35 +000031#include <algorithm>
32
Rui Ueyamafccf7ef2014-10-27 07:44:40 +000033#if defined(HAVE_CXXABI_H)
Nick Kledzikbe43d7e2014-09-30 23:15:39 +000034#include <cxxabi.h>
35#endif
36
Nick Kledzik2458bec2014-07-16 19:49:02 +000037using lld::mach_o::ArchHandler;
Nick Kledzik8fc67fb2014-08-13 23:55:41 +000038using lld::mach_o::MachODylibFile;
Nick Kledzike34182f2013-11-06 21:36:55 +000039using namespace llvm::MachO;
Rui Ueyama0ca149f2013-08-06 22:31:59 +000040
41namespace lld {
42
Nick Kledzike850d9d2013-09-10 23:46:57 +000043bool MachOLinkingContext::parsePackedVersion(StringRef str, uint32_t &result) {
44 result = 0;
Rui Ueyama0ca149f2013-08-06 22:31:59 +000045
46 if (str.empty())
47 return false;
48
49 SmallVector<StringRef, 3> parts;
50 llvm::SplitString(str, parts, ".");
51
52 unsigned long long num;
53 if (llvm::getAsUnsignedInteger(parts[0], 10, num))
54 return true;
55 if (num > 65535)
56 return true;
Nick Kledzike850d9d2013-09-10 23:46:57 +000057 result = num << 16;
Rui Ueyama0ca149f2013-08-06 22:31:59 +000058
59 if (parts.size() > 1) {
60 if (llvm::getAsUnsignedInteger(parts[1], 10, num))
61 return true;
62 if (num > 255)
63 return true;
Nick Kledzike850d9d2013-09-10 23:46:57 +000064 result |= (num << 8);
Rui Ueyama0ca149f2013-08-06 22:31:59 +000065 }
66
67 if (parts.size() > 2) {
68 if (llvm::getAsUnsignedInteger(parts[2], 10, num))
69 return true;
70 if (num > 255)
71 return true;
Nick Kledzike850d9d2013-09-10 23:46:57 +000072 result |= num;
Rui Ueyama0ca149f2013-08-06 22:31:59 +000073 }
74
75 return false;
76}
77
Nick Kledzike34182f2013-11-06 21:36:55 +000078MachOLinkingContext::ArchInfo MachOLinkingContext::_s_archInfos[] = {
79 { "x86_64", arch_x86_64, true, CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL },
80 { "i386", arch_x86, true, CPU_TYPE_I386, CPU_SUBTYPE_X86_ALL },
81 { "ppc", arch_ppc, false, CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL },
82 { "armv6", arch_armv6, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6 },
83 { "armv7", arch_armv7, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7 },
84 { "armv7s", arch_armv7s, true, CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S },
Nick Kledzik1bebb282014-09-09 23:52:59 +000085 { "arm64", arch_arm64, true, CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL },
Nick Kledzike34182f2013-11-06 21:36:55 +000086 { "", arch_unknown,false, 0, 0 }
Rui Ueyama0ca149f2013-08-06 22:31:59 +000087};
88
89MachOLinkingContext::Arch
90MachOLinkingContext::archFromCpuType(uint32_t cputype, uint32_t cpusubtype) {
Nick Kledzike34182f2013-11-06 21:36:55 +000091 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
92 if ((info->cputype == cputype) && (info->cpusubtype == cpusubtype))
Rui Ueyama0ca149f2013-08-06 22:31:59 +000093 return info->arch;
Rui Ueyama0ca149f2013-08-06 22:31:59 +000094 }
95 return arch_unknown;
96}
97
98MachOLinkingContext::Arch
99MachOLinkingContext::archFromName(StringRef archName) {
Nick Kledzike34182f2013-11-06 21:36:55 +0000100 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
101 if (info->archName.equals(archName))
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000102 return info->arch;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000103 }
104 return arch_unknown;
105}
106
Nick Kledzike5552772013-12-19 21:58:00 +0000107StringRef MachOLinkingContext::nameFromArch(Arch arch) {
108 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
109 if (info->arch == arch)
110 return info->archName;
111 }
112 return "<unknown>";
113}
114
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000115uint32_t MachOLinkingContext::cpuTypeFromArch(Arch arch) {
116 assert(arch != arch_unknown);
Nick Kledzike34182f2013-11-06 21:36:55 +0000117 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
118 if (info->arch == arch)
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000119 return info->cputype;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000120 }
121 llvm_unreachable("Unknown arch type");
122}
123
124uint32_t MachOLinkingContext::cpuSubtypeFromArch(Arch arch) {
125 assert(arch != arch_unknown);
Nick Kledzike34182f2013-11-06 21:36:55 +0000126 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
127 if (info->arch == arch)
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000128 return info->cpusubtype;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000129 }
130 llvm_unreachable("Unknown arch type");
131}
132
Nick Kledzik635f9c72014-09-04 20:08:30 +0000133bool MachOLinkingContext::isThinObjectFile(StringRef path, Arch &arch) {
134 return mach_o::normalized::isThinObjectFile(path, arch);
135}
136
Rafael Espindolaed48e532015-04-27 22:48:51 +0000137bool MachOLinkingContext::sliceFromFatFile(MemoryBufferRef mb, uint32_t &offset,
Nick Kledzik14b5d202014-10-08 01:48:10 +0000138 uint32_t &size) {
139 return mach_o::normalized::sliceFromFatFile(mb, _arch, offset, size);
140}
141
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000142MachOLinkingContext::MachOLinkingContext()
Tim Northoverd30a1f22014-06-20 15:59:00 +0000143 : _outputMachOType(MH_EXECUTE), _outputMachOTypeStatic(false),
Tim Northoveraf3075b2014-09-10 10:39:57 +0000144 _doNothing(false), _pie(false), _arch(arch_unknown), _os(OS::macOSX),
145 _osMinVersion(0), _pageZeroSize(0), _pageSize(4096), _baseAddress(0),
Lang Hamesff4b13c2015-05-22 00:25:34 +0000146 _stackSize(0), _compatibilityVersion(0), _currentVersion(0),
Lang Hames5c692002015-09-28 20:25:14 +0000147 _flatNamespace(false), _undefinedMode(UndefinedMode::error),
Lang Hames65a64c92015-05-20 22:10:50 +0000148 _deadStrippableDylib(false), _printAtoms(false), _testingFileUsage(false),
149 _keepPrivateExterns(false), _demangle(false), _archHandler(nullptr),
Nick Kledzik8f75da02014-11-06 03:03:42 +0000150 _exportMode(ExportMode::globals),
Lang Hames5c692002015-09-28 20:25:14 +0000151 _debugInfoMode(DebugInfoMode::addDebugMap), _orderFileEntries(0),
152 _flatNamespaceFile(nullptr) {}
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000153
154MachOLinkingContext::~MachOLinkingContext() {}
155
Nick Kledzik6960b072013-12-21 01:47:17 +0000156void MachOLinkingContext::configure(HeaderFileType type, Arch arch, OS os,
157 uint32_t minOSVersion) {
Tim Northoverd30a1f22014-06-20 15:59:00 +0000158 _outputMachOType = type;
Nick Kledzik6960b072013-12-21 01:47:17 +0000159 _arch = arch;
160 _os = os;
161 _osMinVersion = minOSVersion;
162
Nick Kledzikcb2018f2014-10-09 01:01:16 +0000163 // If min OS not specified on command line, use reasonable defaults.
164 if (minOSVersion == 0) {
165 switch (_arch) {
166 case arch_x86_64:
167 case arch_x86:
168 parsePackedVersion("10.8", _osMinVersion);
169 _os = MachOLinkingContext::OS::macOSX;
170 break;
171 case arch_armv6:
172 case arch_armv7:
173 case arch_armv7s:
174 case arch_arm64:
175 parsePackedVersion("7.0", _osMinVersion);
176 _os = MachOLinkingContext::OS::iOS;
177 break;
178 default:
179 break;
180 }
181 }
182
Tim Northoverd30a1f22014-06-20 15:59:00 +0000183 switch (_outputMachOType) {
Nick Kledzik6960b072013-12-21 01:47:17 +0000184 case llvm::MachO::MH_EXECUTE:
185 // If targeting newer OS, use _main
186 if (minOS("10.8", "6.0")) {
187 _entrySymbolName = "_main";
188 } else {
189 // If targeting older OS, use start (in crt1.o)
190 _entrySymbolName = "start";
191 }
192
193 // __PAGEZERO defaults to 4GB on 64-bit (except for PP64 which lld does not
194 // support) and 4KB on 32-bit.
195 if (is64Bit(_arch)) {
196 _pageZeroSize = 0x100000000;
197 } else {
198 _pageZeroSize = 0x1000;
199 }
200
Lang Hamesc80344282015-09-21 22:06:02 +0000201 // Initial base address is __PAGEZERO size.
202 _baseAddress = _pageZeroSize;
203
Nick Kledzikb7035ae2014-09-09 00:17:52 +0000204 // Make PIE by default when targetting newer OSs.
205 switch (os) {
206 case OS::macOSX:
207 if (minOSVersion >= 0x000A0700) // MacOSX 10.7
208 _pie = true;
209 break;
210 case OS::iOS:
211 if (minOSVersion >= 0x00040300) // iOS 4.3
212 _pie = true;
213 break;
214 case OS::iOS_simulator:
215 _pie = true;
216 break;
217 case OS::unknown:
218 break;
219 }
Nick Kledzik6960b072013-12-21 01:47:17 +0000220 break;
221 case llvm::MachO::MH_DYLIB:
Davide Italiano7b68b902015-03-09 06:05:42 +0000222 setGlobalsAreDeadStripRoots(true);
Nick Kledzik6960b072013-12-21 01:47:17 +0000223 break;
224 case llvm::MachO::MH_BUNDLE:
225 break;
226 case llvm::MachO::MH_OBJECT:
227 _printRemainingUndefines = false;
228 _allowRemainingUndefines = true;
229 default:
230 break;
231 }
Nick Kledzik1bebb282014-09-09 23:52:59 +0000232
233 // Set default segment page sizes based on arch.
234 if (arch == arch_arm64)
235 _pageSize = 4*4096;
Nick Kledzik6960b072013-12-21 01:47:17 +0000236}
237
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000238uint32_t MachOLinkingContext::getCPUType() const {
239 return cpuTypeFromArch(_arch);
240}
241
242uint32_t MachOLinkingContext::getCPUSubType() const {
243 return cpuSubtypeFromArch(_arch);
244}
245
Nick Kledzike34182f2013-11-06 21:36:55 +0000246bool MachOLinkingContext::is64Bit(Arch arch) {
247 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
248 if (info->arch == arch) {
249 return (info->cputype & CPU_ARCH_ABI64);
250 }
251 }
252 // unknown archs are not 64-bit.
253 return false;
254}
255
256bool MachOLinkingContext::isHostEndian(Arch arch) {
257 assert(arch != arch_unknown);
258 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
259 if (info->arch == arch) {
260 return (info->littleEndian == llvm::sys::IsLittleEndianHost);
261 }
262 }
263 llvm_unreachable("Unknown arch type");
264}
265
266bool MachOLinkingContext::isBigEndian(Arch arch) {
267 assert(arch != arch_unknown);
268 for (ArchInfo *info = _s_archInfos; !info->archName.empty(); ++info) {
269 if (info->arch == arch) {
270 return ! info->littleEndian;
271 }
272 }
273 llvm_unreachable("Unknown arch type");
274}
275
Nick Kledzike34182f2013-11-06 21:36:55 +0000276bool MachOLinkingContext::is64Bit() const {
277 return is64Bit(_arch);
278}
279
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000280bool MachOLinkingContext::outputTypeHasEntry() const {
Tim Northoverd30a1f22014-06-20 15:59:00 +0000281 switch (_outputMachOType) {
Nick Kledzike34182f2013-11-06 21:36:55 +0000282 case MH_EXECUTE:
283 case MH_DYLINKER:
284 case MH_PRELOAD:
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000285 return true;
286 default:
287 return false;
288 }
289}
290
Nick Kledzik2458bec2014-07-16 19:49:02 +0000291bool MachOLinkingContext::needsStubsPass() const {
292 switch (_outputMachOType) {
293 case MH_EXECUTE:
294 return !_outputMachOTypeStatic;
295 case MH_DYLIB:
296 case MH_BUNDLE:
297 return true;
298 default:
299 return false;
300 }
301}
302
303bool MachOLinkingContext::needsGOTPass() const {
Nick Kledzik1bebb282014-09-09 23:52:59 +0000304 // GOT pass not used in -r mode.
305 if (_outputMachOType == MH_OBJECT)
Nick Kledzik2458bec2014-07-16 19:49:02 +0000306 return false;
Nick Kledzik1bebb282014-09-09 23:52:59 +0000307 // Only some arches use GOT pass.
308 switch (_arch) {
309 case arch_x86_64:
310 case arch_arm64:
311 return true;
312 default:
313 return false;
314 }
Nick Kledzik2458bec2014-07-16 19:49:02 +0000315}
316
Tim Northovercf78d372014-09-30 21:29:54 +0000317bool MachOLinkingContext::needsCompactUnwindPass() const {
318 switch (_outputMachOType) {
319 case MH_EXECUTE:
320 case MH_DYLIB:
321 case MH_BUNDLE:
322 return archHandler().needsCompactUnwind();
323 default:
324 return false;
325 }
326}
Nick Kledzik2458bec2014-07-16 19:49:02 +0000327
Nick Kledzik4121bce2014-10-14 01:51:42 +0000328bool MachOLinkingContext::needsShimPass() const {
329 // Shim pass only used in final executables.
330 if (_outputMachOType == MH_OBJECT)
331 return false;
332 // Only 32-bit arm arches use Shim pass.
333 switch (_arch) {
334 case arch_armv6:
335 case arch_armv7:
336 case arch_armv7s:
337 return true;
338 default:
339 return false;
340 }
341}
342
Lang Hames49047032015-06-23 20:35:31 +0000343bool MachOLinkingContext::needsTLVPass() const {
344 switch (_outputMachOType) {
345 case MH_BUNDLE:
346 case MH_EXECUTE:
347 case MH_DYLIB:
348 return true;
349 default:
350 return false;
351 }
352}
353
Nick Kledzik2458bec2014-07-16 19:49:02 +0000354StringRef MachOLinkingContext::binderSymbolName() const {
355 return archHandler().stubInfo().binderSymbolName;
356}
357
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000358bool MachOLinkingContext::minOS(StringRef mac, StringRef iOS) const {
Nick Kledzik30332b12013-10-08 00:43:34 +0000359 uint32_t parsedVersion;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000360 switch (_os) {
Nick Kledzik30332b12013-10-08 00:43:34 +0000361 case OS::macOSX:
Nick Kledzike850d9d2013-09-10 23:46:57 +0000362 if (parsePackedVersion(mac, parsedVersion))
363 return false;
364 return _osMinVersion >= parsedVersion;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000365 case OS::iOS:
Nick Kledzik30332b12013-10-08 00:43:34 +0000366 case OS::iOS_simulator:
Nick Kledzike850d9d2013-09-10 23:46:57 +0000367 if (parsePackedVersion(iOS, parsedVersion))
368 return false;
369 return _osMinVersion >= parsedVersion;
Nick Kledzik30332b12013-10-08 00:43:34 +0000370 case OS::unknown:
371 break;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000372 }
373 llvm_unreachable("target not configured for iOS or MacOSX");
374}
375
376bool MachOLinkingContext::addEntryPointLoadCommand() const {
Tim Northoverd30a1f22014-06-20 15:59:00 +0000377 if ((_outputMachOType == MH_EXECUTE) && !_outputMachOTypeStatic) {
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000378 return minOS("10.8", "6.0");
379 }
380 return false;
381}
382
383bool MachOLinkingContext::addUnixThreadLoadCommand() const {
Tim Northoverd30a1f22014-06-20 15:59:00 +0000384 switch (_outputMachOType) {
Nick Kledzike34182f2013-11-06 21:36:55 +0000385 case MH_EXECUTE:
Tim Northoverd30a1f22014-06-20 15:59:00 +0000386 if (_outputMachOTypeStatic)
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000387 return true;
388 else
389 return !minOS("10.8", "6.0");
390 break;
Nick Kledzike34182f2013-11-06 21:36:55 +0000391 case MH_DYLINKER:
392 case MH_PRELOAD:
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000393 return true;
394 default:
395 return false;
396 }
397}
398
Tim Northover77d82202014-07-10 11:21:06 +0000399bool MachOLinkingContext::pathExists(StringRef path) const {
Nick Kledzik94174f72014-08-15 19:53:41 +0000400 if (!_testingFileUsage)
Tim Northover77d82202014-07-10 11:21:06 +0000401 return llvm::sys::fs::exists(path.str());
402
403 // Otherwise, we're in test mode: only files explicitly provided on the
404 // command-line exist.
Rui Ueyama57a29532014-08-06 19:37:35 +0000405 std::string key = path.str();
406 std::replace(key.begin(), key.end(), '\\', '/');
407 return _existingPaths.find(key) != _existingPaths.end();
Tim Northover77d82202014-07-10 11:21:06 +0000408}
409
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000410bool MachOLinkingContext::fileExists(StringRef path) const {
411 bool found = pathExists(path);
412 // Log search misses.
413 if (!found)
414 addInputFileNotFound(path);
415
416 // When testing, file is never opened, so logging is done here.
417 if (_testingFileUsage && found)
418 addInputFileDependency(path);
419
420 return found;
421}
422
Nick Kledzik2d835da2014-08-14 22:20:41 +0000423void MachOLinkingContext::setSysLibRoots(const StringRefVector &paths) {
424 _syslibRoots = paths;
425}
426
Jean-Daniel Dupas23dd15e2014-12-18 21:33:38 +0000427void MachOLinkingContext::addRpath(StringRef rpath) {
428 _rpaths.push_back(rpath);
429}
430
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000431void MachOLinkingContext::addModifiedSearchDir(StringRef libPath,
432 bool isSystemPath) {
Tim Northover77d82202014-07-10 11:21:06 +0000433 bool addedModifiedPath = false;
434
Nick Kledzik2d835da2014-08-14 22:20:41 +0000435 // -syslibroot only applies to absolute paths.
436 if (libPath.startswith("/")) {
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000437 for (auto syslibRoot : _syslibRoots) {
Tim Northover77d82202014-07-10 11:21:06 +0000438 SmallString<256> path(syslibRoot);
439 llvm::sys::path::append(path, libPath);
440 if (pathExists(path)) {
441 _searchDirs.push_back(path.str().copy(_allocator));
442 addedModifiedPath = true;
443 }
444 }
445 }
446
447 if (addedModifiedPath)
448 return;
449
450 // Finally, if only one -syslibroot is given, system paths which aren't in it
451 // get suppressed.
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000452 if (_syslibRoots.size() != 1 || !isSystemPath) {
Tim Northover77d82202014-07-10 11:21:06 +0000453 if (pathExists(libPath)) {
454 _searchDirs.push_back(libPath);
455 }
456 }
457}
458
Nick Kledzik2d835da2014-08-14 22:20:41 +0000459void MachOLinkingContext::addFrameworkSearchDir(StringRef fwPath,
460 bool isSystemPath) {
461 bool pathAdded = false;
462
463 // -syslibroot only used with to absolute framework search paths.
464 if (fwPath.startswith("/")) {
465 for (auto syslibRoot : _syslibRoots) {
466 SmallString<256> path(syslibRoot);
467 llvm::sys::path::append(path, fwPath);
468 if (pathExists(path)) {
469 _frameworkDirs.push_back(path.str().copy(_allocator));
470 pathAdded = true;
471 }
472 }
473 }
474 // If fwPath found in any -syslibroot, then done.
475 if (pathAdded)
476 return;
477
478 // If only one -syslibroot, system paths not in that SDK are suppressed.
479 if (isSystemPath && (_syslibRoots.size() == 1))
480 return;
481
482 // Only use raw fwPath if that directory exists.
483 if (pathExists(fwPath))
484 _frameworkDirs.push_back(fwPath);
485}
486
Tim Northover77d82202014-07-10 11:21:06 +0000487ErrorOr<StringRef>
488MachOLinkingContext::searchDirForLibrary(StringRef path,
489 StringRef libName) const {
490 SmallString<256> fullPath;
491 if (libName.endswith(".o")) {
492 // A request ending in .o is special: just search for the file directly.
493 fullPath.assign(path);
494 llvm::sys::path::append(fullPath, libName);
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000495 if (fileExists(fullPath))
Tim Northover77d82202014-07-10 11:21:06 +0000496 return fullPath.str().copy(_allocator);
497 return make_error_code(llvm::errc::no_such_file_or_directory);
498 }
499
500 // Search for dynamic library
501 fullPath.assign(path);
502 llvm::sys::path::append(fullPath, Twine("lib") + libName + ".dylib");
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000503 if (fileExists(fullPath))
Tim Northover77d82202014-07-10 11:21:06 +0000504 return fullPath.str().copy(_allocator);
505
506 // If not, try for a static library
507 fullPath.assign(path);
508 llvm::sys::path::append(fullPath, Twine("lib") + libName + ".a");
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000509 if (fileExists(fullPath))
Tim Northover77d82202014-07-10 11:21:06 +0000510 return fullPath.str().copy(_allocator);
511
512 return make_error_code(llvm::errc::no_such_file_or_directory);
513}
514
Tim Northover77d82202014-07-10 11:21:06 +0000515ErrorOr<StringRef> MachOLinkingContext::searchLibrary(StringRef libName) const {
516 SmallString<256> path;
517 for (StringRef dir : searchDirs()) {
518 ErrorOr<StringRef> ec = searchDirForLibrary(dir, libName);
519 if (ec)
520 return ec;
521 }
522
523 return make_error_code(llvm::errc::no_such_file_or_directory);
524}
525
Nick Kledzik2d835da2014-08-14 22:20:41 +0000526ErrorOr<StringRef> MachOLinkingContext::findPathForFramework(StringRef fwName) const{
527 SmallString<256> fullPath;
528 for (StringRef dir : frameworkDirs()) {
529 fullPath.assign(dir);
530 llvm::sys::path::append(fullPath, Twine(fwName) + ".framework", fwName);
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000531 if (fileExists(fullPath))
Nick Kledzik2d835da2014-08-14 22:20:41 +0000532 return fullPath.str().copy(_allocator);
533 }
534
535 return make_error_code(llvm::errc::no_such_file_or_directory);
536}
537
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000538bool MachOLinkingContext::validateImpl(raw_ostream &diagnostics) {
Nick Kledzike34182f2013-11-06 21:36:55 +0000539 // TODO: if -arch not specified, look at arch of first .o file.
540
Tim Northoverd30a1f22014-06-20 15:59:00 +0000541 if (_currentVersion && _outputMachOType != MH_DYLIB) {
Nick Kledzike773e322013-09-10 23:55:14 +0000542 diagnostics << "error: -current_version can only be used with dylibs\n";
Rui Ueyama8db1edd2013-09-24 23:26:34 +0000543 return false;
Nick Kledzike773e322013-09-10 23:55:14 +0000544 }
545
Tim Northoverd30a1f22014-06-20 15:59:00 +0000546 if (_compatibilityVersion && _outputMachOType != MH_DYLIB) {
Nick Kledzike773e322013-09-10 23:55:14 +0000547 diagnostics
548 << "error: -compatibility_version can only be used with dylibs\n";
Rui Ueyama8db1edd2013-09-24 23:26:34 +0000549 return false;
Nick Kledzike773e322013-09-10 23:55:14 +0000550 }
551
Tim Northoverd30a1f22014-06-20 15:59:00 +0000552 if (_deadStrippableDylib && _outputMachOType != MH_DYLIB) {
Nick Kledzike773e322013-09-10 23:55:14 +0000553 diagnostics
554 << "error: -mark_dead_strippable_dylib can only be used with dylibs.\n";
Rui Ueyama8db1edd2013-09-24 23:26:34 +0000555 return false;
Nick Kledzike773e322013-09-10 23:55:14 +0000556 }
557
Tim Northoverd30a1f22014-06-20 15:59:00 +0000558 if (!_bundleLoader.empty() && outputMachOType() != MH_BUNDLE) {
Nick Kledzike773e322013-09-10 23:55:14 +0000559 diagnostics
560 << "error: -bundle_loader can only be used with Mach-O bundles\n";
Rui Ueyama8db1edd2013-09-24 23:26:34 +0000561 return false;
Nick Kledzike773e322013-09-10 23:55:14 +0000562 }
563
Nick Kledzik8c0bf752014-08-21 01:59:11 +0000564 // If -exported_symbols_list used, all exported symbols must be defined.
565 if (_exportMode == ExportMode::whiteList) {
566 for (const auto &symbol : _exportedSymbols)
567 addInitialUndefinedSymbol(symbol.getKey());
568 }
569
Nick Kledzik77afc712014-08-21 20:25:50 +0000570 // If -dead_strip, set up initial live symbols.
571 if (deadStrip()) {
572 // Entry point is live.
573 if (outputTypeHasEntry())
574 addDeadStripRoot(entrySymbolName());
575 // Lazy binding helper is live.
576 if (needsStubsPass())
577 addDeadStripRoot(binderSymbolName());
578 // If using -exported_symbols_list, make all exported symbols live.
579 if (_exportMode == ExportMode::whiteList) {
Davide Italiano7b68b902015-03-09 06:05:42 +0000580 setGlobalsAreDeadStripRoots(false);
Nick Kledzik77afc712014-08-21 20:25:50 +0000581 for (const auto &symbol : _exportedSymbols)
582 addDeadStripRoot(symbol.getKey());
583 }
584 }
585
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000586 addOutputFileDependency(outputPath());
587
Rui Ueyama8db1edd2013-09-24 23:26:34 +0000588 return true;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000589}
590
Shankar Easwaran2bc24922013-10-29 05:12:14 +0000591void MachOLinkingContext::addPasses(PassManager &pm) {
Rui Ueyama00762152015-02-05 20:05:33 +0000592 mach_o::addLayoutPass(pm, *this);
Nick Kledzik2458bec2014-07-16 19:49:02 +0000593 if (needsStubsPass())
594 mach_o::addStubsPass(pm, *this);
Tim Northovercf78d372014-09-30 21:29:54 +0000595 if (needsCompactUnwindPass())
596 mach_o::addCompactUnwindPass(pm, *this);
Nick Kledzik2458bec2014-07-16 19:49:02 +0000597 if (needsGOTPass())
598 mach_o::addGOTPass(pm, *this);
Lang Hames49047032015-06-23 20:35:31 +0000599 if (needsTLVPass())
600 mach_o::addTLVPass(pm, *this);
Nick Kledzik4121bce2014-10-14 01:51:42 +0000601 if (needsShimPass())
602 mach_o::addShimPass(pm, *this); // Shim pass must run after stubs pass.
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000603}
604
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000605Writer &MachOLinkingContext::writer() const {
Tim Northoverd30a1f22014-06-20 15:59:00 +0000606 if (!_writer)
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000607 _writer = createWriterMachO(*this);
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000608 return *_writer;
609}
610
Greg Fitzgeraldb4eb64e2015-01-23 23:26:13 +0000611ErrorOr<std::unique_ptr<MemoryBuffer>>
612MachOLinkingContext::getMemoryBuffer(StringRef path) {
613 addInputFileDependency(path);
614
Rui Ueyamadf230b22015-01-15 04:34:31 +0000615 ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr =
Greg Fitzgeraldb4eb64e2015-01-23 23:26:13 +0000616 MemoryBuffer::getFileOrSTDIN(path);
617 if (std::error_code ec = mbOrErr.getError())
618 return ec;
619 std::unique_ptr<MemoryBuffer> mb = std::move(mbOrErr.get());
620
621 // If buffer contains a fat file, find required arch in fat buffer
622 // and switch buffer to point to just that required slice.
623 uint32_t offset;
624 uint32_t size;
Rafael Espindolaed48e532015-04-27 22:48:51 +0000625 if (sliceFromFatFile(mb->getMemBufferRef(), offset, size))
Greg Fitzgeraldb4eb64e2015-01-23 23:26:13 +0000626 return MemoryBuffer::getFileSlice(path, size, offset);
627 return std::move(mb);
628}
629
630MachODylibFile* MachOLinkingContext::loadIndirectDylib(StringRef path) {
631 ErrorOr<std::unique_ptr<MemoryBuffer>> mbOrErr = getMemoryBuffer(path);
Rui Ueyamadf230b22015-01-15 04:34:31 +0000632 if (mbOrErr.getError())
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000633 return nullptr;
634
Rafael Espindolaab5696b2015-04-24 18:51:30 +0000635 ErrorOr<std::unique_ptr<File>> fileOrErr =
636 registry().loadFile(std::move(mbOrErr.get()));
637 if (!fileOrErr)
Rui Ueyamadf230b22015-01-15 04:34:31 +0000638 return nullptr;
Rafael Espindola773a1592015-04-24 19:01:30 +0000639 std::unique_ptr<File> &file = fileOrErr.get();
640 file->parse();
641 MachODylibFile *result = reinterpret_cast<MachODylibFile *>(file.get());
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000642 // Node object now owned by _indirectDylibs vector.
Rafael Espindola773a1592015-04-24 19:01:30 +0000643 _indirectDylibs.push_back(std::move(file));
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000644 return result;
645}
646
Nick Kledzik22c90732014-10-01 20:24:30 +0000647MachODylibFile* MachOLinkingContext::findIndirectDylib(StringRef path) {
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000648 // See if already loaded.
649 auto pos = _pathToDylibMap.find(path);
650 if (pos != _pathToDylibMap.end())
651 return pos->second;
652
653 // Search -L paths if of the form "libXXX.dylib"
654 std::pair<StringRef, StringRef> split = path.rsplit('/');
655 StringRef leafName = split.second;
656 if (leafName.startswith("lib") && leafName.endswith(".dylib")) {
657 // FIXME: Need to enhance searchLibrary() to only look for .dylib
658 auto libPath = searchLibrary(leafName);
659 if (!libPath.getError()) {
660 return loadIndirectDylib(libPath.get());
661 }
662 }
663
664 // Try full path with sysroot.
665 for (StringRef sysPath : _syslibRoots) {
666 SmallString<256> fullPath;
667 fullPath.assign(sysPath);
668 llvm::sys::path::append(fullPath, path);
669 if (pathExists(fullPath))
670 return loadIndirectDylib(fullPath);
671 }
672
673 // Try full path.
674 if (pathExists(path)) {
675 return loadIndirectDylib(path);
676 }
677
678 return nullptr;
679}
680
Nick Kledzik5b9e48b2014-11-19 02:21:53 +0000681uint32_t MachOLinkingContext::dylibCurrentVersion(StringRef installName) const {
682 auto pos = _pathToDylibMap.find(installName);
683 if (pos != _pathToDylibMap.end())
684 return pos->second->currentVersion();
685 else
686 return 0x1000; // 1.0
687}
688
689uint32_t MachOLinkingContext::dylibCompatVersion(StringRef installName) const {
690 auto pos = _pathToDylibMap.find(installName);
691 if (pos != _pathToDylibMap.end())
692 return pos->second->compatVersion();
693 else
694 return 0x1000; // 1.0
695}
696
Simon Atanasyanc4378882015-04-06 20:43:35 +0000697void MachOLinkingContext::createImplicitFiles(
Nick Kledzik22c90732014-10-01 20:24:30 +0000698 std::vector<std::unique_ptr<File> > &result) {
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000699 // Add indirect dylibs by asking each linked dylib to add its indirects.
700 // Iterate until no more dylibs get loaded.
701 size_t dylibCount = 0;
702 while (dylibCount != _allDylibs.size()) {
703 dylibCount = _allDylibs.size();
704 for (MachODylibFile *dylib : _allDylibs) {
705 dylib->loadReExportedDylibs([this] (StringRef path) -> MachODylibFile* {
706 return findIndirectDylib(path); });
707 }
708 }
709
710 // Let writer add output type specific extras.
Simon Atanasyanc4378882015-04-06 20:43:35 +0000711 writer().createImplicitFiles(result);
Lang Hames5c692002015-09-28 20:25:14 +0000712
Lang Hames9a4c94e2015-09-28 20:52:21 +0000713 // If undefinedMode is != error, add a FlatNamespaceFile instance. This will
714 // provide a SharedLibraryAtom for symbols that aren't defined elsewhere.
715 if (undefinedMode() != UndefinedMode::error) {
716 result.emplace_back(new mach_o::FlatNamespaceFile(*this));
Lang Hames5c692002015-09-28 20:25:14 +0000717 _flatNamespaceFile = result.back().get();
718 }
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000719}
720
Nick Kledzik51720672014-10-16 19:31:28 +0000721void MachOLinkingContext::registerDylib(MachODylibFile *dylib,
722 bool upward) const {
Lang Hames9bbc3652015-05-13 00:17:08 +0000723 std::lock_guard<std::mutex> lock(_dylibsMutex);
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000724 _allDylibs.insert(dylib);
725 _pathToDylibMap[dylib->installName()] = dylib;
726 // If path is different than install name, register path too.
727 if (!dylib->path().equals(dylib->installName()))
728 _pathToDylibMap[dylib->path()] = dylib;
Nick Kledzik51720672014-10-16 19:31:28 +0000729 if (upward)
730 _upwardDylibs.insert(dylib);
Nick Kledzik8fc67fb2014-08-13 23:55:41 +0000731}
732
Nick Kledzik51720672014-10-16 19:31:28 +0000733bool MachOLinkingContext::isUpwardDylib(StringRef installName) const {
734 for (MachODylibFile *dylib : _upwardDylibs) {
735 if (dylib->installName().equals(installName))
736 return true;
737 }
738 return false;
739}
740
Nick Kledzik2458bec2014-07-16 19:49:02 +0000741ArchHandler &MachOLinkingContext::archHandler() const {
742 if (!_archHandler)
743 _archHandler = ArchHandler::create(_arch);
744 return *_archHandler;
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000745}
746
Nick Kledzik2fcbe822014-07-30 00:58:06 +0000747void MachOLinkingContext::addSectionAlignment(StringRef seg, StringRef sect,
Rui Ueyamada74d572015-03-26 02:23:45 +0000748 uint16_t align) {
749 SectionAlign entry = { seg, sect, align };
Nick Kledzik2fcbe822014-07-30 00:58:06 +0000750 _sectAligns.push_back(entry);
751}
752
Lang Hamesb1b67f42015-10-24 08:20:51 +0000753void MachOLinkingContext::addSectCreateSection(
754 StringRef seg, StringRef sect,
755 std::unique_ptr<MemoryBuffer> content) {
756
757 if (!_sectCreateFile) {
758 auto sectCreateFile = llvm::make_unique<mach_o::SectCreateFile>();
759 _sectCreateFile = sectCreateFile.get();
760 getNodes().push_back(llvm::make_unique<FileNode>(std::move(sectCreateFile)));
761 }
762
763 assert(_sectCreateFile && "sectcreate file does not exist.");
764 _sectCreateFile->addSection(seg, sect, std::move(content));
765}
766
Nick Kledzik2fcbe822014-07-30 00:58:06 +0000767bool MachOLinkingContext::sectionAligned(StringRef seg, StringRef sect,
Rui Ueyamada74d572015-03-26 02:23:45 +0000768 uint16_t &align) const {
Nick Kledzik2fcbe822014-07-30 00:58:06 +0000769 for (const SectionAlign &entry : _sectAligns) {
770 if (seg.equals(entry.segmentName) && sect.equals(entry.sectionName)) {
Rui Ueyamada74d572015-03-26 02:23:45 +0000771 align = entry.align;
Nick Kledzik2fcbe822014-07-30 00:58:06 +0000772 return true;
773 }
774 }
775 return false;
776}
777
Nick Kledzik8c0bf752014-08-21 01:59:11 +0000778void MachOLinkingContext::addExportSymbol(StringRef sym) {
Nick Kledzik4183dbc2014-10-24 22:28:54 +0000779 // Support old crufty export lists with bogus entries.
780 if (sym.endswith(".eh") || sym.startswith(".objc_category_name_")) {
781 llvm::errs() << "warning: ignoring " << sym << " in export list\n";
782 return;
783 }
784 // Only i386 MacOSX uses old ABI, so don't change those.
785 if ((_os != OS::macOSX) || (_arch != arch_x86)) {
786 // ObjC has two differnent ABIs. Be nice and allow one export list work for
787 // both ABIs by renaming symbols.
788 if (sym.startswith(".objc_class_name_")) {
789 std::string abi2className("_OBJC_CLASS_$_");
790 abi2className += sym.substr(17);
791 _exportedSymbols.insert(copy(abi2className));
792 std::string abi2metaclassName("_OBJC_METACLASS_$_");
793 abi2metaclassName += sym.substr(17);
794 _exportedSymbols.insert(copy(abi2metaclassName));
795 return;
796 }
797 }
798
Nick Kledzik8c0bf752014-08-21 01:59:11 +0000799 // FIXME: Support wildcards.
800 _exportedSymbols.insert(sym);
801}
802
803bool MachOLinkingContext::exportSymbolNamed(StringRef sym) const {
804 switch (_exportMode) {
805 case ExportMode::globals:
806 llvm_unreachable("exportSymbolNamed() should not be called in this mode");
807 break;
808 case ExportMode::whiteList:
809 return _exportedSymbols.count(sym);
810 case ExportMode::blackList:
811 return !_exportedSymbols.count(sym);
812 }
Yaron Keren9682c852014-09-21 05:07:44 +0000813 llvm_unreachable("_exportMode unknown enum value");
Nick Kledzik8c0bf752014-08-21 01:59:11 +0000814}
815
Nick Kledzikbe43d7e2014-09-30 23:15:39 +0000816std::string MachOLinkingContext::demangle(StringRef symbolName) const {
817 // Only try to demangle symbols if -demangle on command line
Davide Italiano6d86bb22015-02-18 03:54:21 +0000818 if (!demangleSymbols())
Nick Kledzikbe43d7e2014-09-30 23:15:39 +0000819 return symbolName;
820
821 // Only try to demangle symbols that look like C++ symbols
822 if (!symbolName.startswith("__Z"))
823 return symbolName;
824
Rui Ueyamafccf7ef2014-10-27 07:44:40 +0000825#if defined(HAVE_CXXABI_H)
Nick Kledzikbe43d7e2014-09-30 23:15:39 +0000826 SmallString<256> symBuff;
827 StringRef nullTermSym = Twine(symbolName).toNullTerminatedStringRef(symBuff);
828 // Mach-O has extra leading underscore that needs to be removed.
829 const char *cstr = nullTermSym.data() + 1;
830 int status;
831 char *demangled = abi::__cxa_demangle(cstr, nullptr, nullptr, &status);
Rui Ueyama43155d02015-10-02 00:36:00 +0000832 if (demangled) {
Nick Kledzikbe43d7e2014-09-30 23:15:39 +0000833 std::string result(demangled);
834 // __cxa_demangle() always uses a malloc'ed buffer to return the result.
835 free(demangled);
836 return result;
837 }
838#endif
839
840 return symbolName;
841}
842
Nick Kledzik09d00bb2014-10-04 00:16:13 +0000843std::error_code MachOLinkingContext::createDependencyFile(StringRef path) {
844 std::error_code ec;
845 _dependencyInfo = std::unique_ptr<llvm::raw_fd_ostream>(new
846 llvm::raw_fd_ostream(path, ec, llvm::sys::fs::F_None));
847 if (ec) {
848 _dependencyInfo.reset();
849 return ec;
850 }
851
852 char linkerVersionOpcode = 0x00;
853 *_dependencyInfo << linkerVersionOpcode;
854 *_dependencyInfo << "lld"; // FIXME
855 *_dependencyInfo << '\0';
856
857 return std::error_code();
858}
859
860void MachOLinkingContext::addInputFileDependency(StringRef path) const {
861 if (!_dependencyInfo)
862 return;
863
864 char inputFileOpcode = 0x10;
865 *_dependencyInfo << inputFileOpcode;
866 *_dependencyInfo << path;
867 *_dependencyInfo << '\0';
868}
869
870void MachOLinkingContext::addInputFileNotFound(StringRef path) const {
871 if (!_dependencyInfo)
872 return;
873
874 char inputFileOpcode = 0x11;
875 *_dependencyInfo << inputFileOpcode;
876 *_dependencyInfo << path;
877 *_dependencyInfo << '\0';
878}
879
880void MachOLinkingContext::addOutputFileDependency(StringRef path) const {
881 if (!_dependencyInfo)
882 return;
883
884 char outputFileOpcode = 0x40;
885 *_dependencyInfo << outputFileOpcode;
886 *_dependencyInfo << path;
887 *_dependencyInfo << '\0';
888}
889
Nick Kledzik82d24bc2014-11-07 21:01:21 +0000890void MachOLinkingContext::appendOrderedSymbol(StringRef symbol,
891 StringRef filename) {
892 // To support sorting static functions which may have the same name in
893 // multiple .o files, _orderFiles maps the symbol name to a vector
894 // of OrderFileNode each of which can specify a file prefix.
895 OrderFileNode info;
896 if (!filename.empty())
897 info.fileFilter = copy(filename);
898 info.order = _orderFileEntries++;
899 _orderFiles[symbol].push_back(info);
900}
901
902bool
903MachOLinkingContext::findOrderOrdinal(const std::vector<OrderFileNode> &nodes,
904 const DefinedAtom *atom,
905 unsigned &ordinal) {
906 const File *objFile = &atom->file();
907 assert(objFile);
908 StringRef objName = objFile->path();
909 std::pair<StringRef, StringRef> dirAndLeaf = objName.rsplit('/');
910 if (!dirAndLeaf.second.empty())
911 objName = dirAndLeaf.second;
912 for (const OrderFileNode &info : nodes) {
913 if (info.fileFilter.empty()) {
914 // Have unprefixed symbol name in order file that matches this atom.
915 ordinal = info.order;
Nick Kledzik82d24bc2014-11-07 21:01:21 +0000916 return true;
917 }
918 if (info.fileFilter.equals(objName)) {
919 // Have prefixed symbol name in order file that matches atom's path.
920 ordinal = info.order;
Nick Kledzik82d24bc2014-11-07 21:01:21 +0000921 return true;
922 }
923 }
924 return false;
925}
926
927bool MachOLinkingContext::customAtomOrderer(const DefinedAtom *left,
928 const DefinedAtom *right,
Rui Ueyama00762152015-02-05 20:05:33 +0000929 bool &leftBeforeRight) const {
Nick Kledzik82d24bc2014-11-07 21:01:21 +0000930 // No custom sorting if no order file entries.
931 if (!_orderFileEntries)
932 return false;
933
934 // Order files can only order named atoms.
935 StringRef leftName = left->name();
936 StringRef rightName = right->name();
937 if (leftName.empty() || rightName.empty())
938 return false;
939
940 // If neither is in order file list, no custom sorter.
941 auto leftPos = _orderFiles.find(leftName);
942 auto rightPos = _orderFiles.find(rightName);
943 bool leftIsOrdered = (leftPos != _orderFiles.end());
944 bool rightIsOrdered = (rightPos != _orderFiles.end());
945 if (!leftIsOrdered && !rightIsOrdered)
946 return false;
947
948 // There could be multiple symbols with same name but different file prefixes.
949 unsigned leftOrder;
950 unsigned rightOrder;
951 bool foundLeft =
952 leftIsOrdered && findOrderOrdinal(leftPos->getValue(), left, leftOrder);
953 bool foundRight = rightIsOrdered &&
954 findOrderOrdinal(rightPos->getValue(), right, rightOrder);
955 if (!foundLeft && !foundRight)
956 return false;
957
958 // If only one is in order file list, ordered one goes first.
959 if (foundLeft != foundRight)
960 leftBeforeRight = foundLeft;
961 else
962 leftBeforeRight = (leftOrder < rightOrder);
963
964 return true;
965}
Nick Kledzik8c0bf752014-08-21 01:59:11 +0000966
Rui Ueyama61635442015-01-15 08:31:46 +0000967static bool isLibrary(const std::unique_ptr<Node> &elem) {
Rui Ueyamaae1daae2015-01-15 08:51:23 +0000968 if (FileNode *node = dyn_cast<FileNode>(const_cast<Node *>(elem.get()))) {
969 File *file = node->getFile();
970 return isa<SharedLibraryFile>(file) || isa<ArchiveLibraryFile>(file);
971 }
972 return false;
Rui Ueyama00eb2572014-12-10 00:33:00 +0000973}
974
975// The darwin linker processes input files in two phases. The first phase
976// links in all object (.o) files in command line order. The second phase
977// links in libraries in command line order.
978// In this function we reorder the input files so that all the object files
979// comes before any library file. We also make a group for the library files
980// so that the Resolver will reiterate over the libraries as long as we find
981// new undefines from libraries.
Denis Protivenskycd617152015-03-14 10:34:43 +0000982void MachOLinkingContext::finalizeInputFiles() {
Rui Ueyama883afba2015-01-15 08:46:36 +0000983 std::vector<std::unique_ptr<Node>> &elements = getNodes();
Rui Ueyama00eb2572014-12-10 00:33:00 +0000984 std::stable_sort(elements.begin(), elements.end(),
Rui Ueyama61635442015-01-15 08:31:46 +0000985 [](const std::unique_ptr<Node> &a,
986 const std::unique_ptr<Node> &b) {
Rui Ueyama00eb2572014-12-10 00:33:00 +0000987 return !isLibrary(a) && isLibrary(b);
988 });
989 size_t numLibs = std::count_if(elements.begin(), elements.end(), isLibrary);
990 elements.push_back(llvm::make_unique<GroupEnd>(numLibs));
991}
992
Rui Ueyama0ca149f2013-08-06 22:31:59 +0000993} // end namespace lld