Coverage Report

Created: 2019-01-18 03:29

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