llvm-project

1
//===- Writer.cpp ---------------------------------------------------------===//
2
//
3
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4
// See https://llvm.org/LICENSE.txt for license information.
5
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6
//
7
//===----------------------------------------------------------------------===//
8

9
#include "Writer.h"
10
#include "ConcatOutputSection.h"
11
#include "Config.h"
12
#include "InputFiles.h"
13
#include "InputSection.h"
14
#include "MapFile.h"
15
#include "OutputSection.h"
16
#include "OutputSegment.h"
17
#include "SectionPriorities.h"
18
#include "SymbolTable.h"
19
#include "Symbols.h"
20
#include "SyntheticSections.h"
21
#include "Target.h"
22
#include "UnwindInfoSection.h"
23

24
#include "lld/Common/Arrays.h"
25
#include "lld/Common/CommonLinkerContext.h"
26
#include "llvm/BinaryFormat/MachO.h"
27
#include "llvm/Config/llvm-config.h"
28
#include "llvm/Support/LEB128.h"
29
#include "llvm/Support/Parallel.h"
30
#include "llvm/Support/Path.h"
31
#include "llvm/Support/ThreadPool.h"
32
#include "llvm/Support/TimeProfiler.h"
33
#include "llvm/Support/xxhash.h"
34

35
#include <algorithm>
36

37
using namespace llvm;
38
using namespace llvm::MachO;
39
using namespace llvm::sys;
40
using namespace lld;
41
using namespace lld::macho;
42

43
namespace {
44
class LCUuid;
45

46
class Writer {
47
public:
48
  Writer() : buffer(errorHandler().outputBuffer) {}
49

50
  void treatSpecialUndefineds();
51
  void scanRelocations();
52
  void scanSymbols();
53
  template <class LP> void createOutputSections();
54
  template <class LP> void createLoadCommands();
55
  void finalizeAddresses();
56
  void finalizeLinkEditSegment();
57
  void assignAddresses(OutputSegment *);
58

59
  void openFile();
60
  void writeSections();
61
  void applyOptimizationHints();
62
  void buildFixupChains();
63
  void writeUuid();
64
  void writeCodeSignature();
65
  void writeOutputFile();
66

67
  template <class LP> void run();
68

69
  DefaultThreadPool threadPool;
70
  std::unique_ptr<FileOutputBuffer> &buffer;
71
  uint64_t addr = 0;
72
  uint64_t fileOff = 0;
73
  MachHeaderSection *header = nullptr;
74
  StringTableSection *stringTableSection = nullptr;
75
  SymtabSection *symtabSection = nullptr;
76
  IndirectSymtabSection *indirectSymtabSection = nullptr;
77
  CodeSignatureSection *codeSignatureSection = nullptr;
78
  DataInCodeSection *dataInCodeSection = nullptr;
79
  FunctionStartsSection *functionStartsSection = nullptr;
80

81
  LCUuid *uuidCommand = nullptr;
82
  OutputSegment *linkEditSegment = nullptr;
83
};
84

85
// LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
86
class LCDyldInfo final : public LoadCommand {
87
public:
88
  LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection,
89
             WeakBindingSection *weakBindingSection,
90
             LazyBindingSection *lazyBindingSection,
91
             ExportSection *exportSection)
92
      : rebaseSection(rebaseSection), bindingSection(bindingSection),
93
        weakBindingSection(weakBindingSection),
94
        lazyBindingSection(lazyBindingSection), exportSection(exportSection) {}
95

96
  uint32_t getSize() const override { return sizeof(dyld_info_command); }
97

98
  void writeTo(uint8_t *buf) const override {
99
    auto *c = reinterpret_cast<dyld_info_command *>(buf);
100
    c->cmd = LC_DYLD_INFO_ONLY;
101
    c->cmdsize = getSize();
102
    if (rebaseSection->isNeeded()) {
103
      c->rebase_off = rebaseSection->fileOff;
104
      c->rebase_size = rebaseSection->getFileSize();
105
    }
106
    if (bindingSection->isNeeded()) {
107
      c->bind_off = bindingSection->fileOff;
108
      c->bind_size = bindingSection->getFileSize();
109
    }
110
    if (weakBindingSection->isNeeded()) {
111
      c->weak_bind_off = weakBindingSection->fileOff;
112
      c->weak_bind_size = weakBindingSection->getFileSize();
113
    }
114
    if (lazyBindingSection->isNeeded()) {
115
      c->lazy_bind_off = lazyBindingSection->fileOff;
116
      c->lazy_bind_size = lazyBindingSection->getFileSize();
117
    }
118
    if (exportSection->isNeeded()) {
119
      c->export_off = exportSection->fileOff;
120
      c->export_size = exportSection->getFileSize();
121
    }
122
  }
123

124
  RebaseSection *rebaseSection;
125
  BindingSection *bindingSection;
126
  WeakBindingSection *weakBindingSection;
127
  LazyBindingSection *lazyBindingSection;
128
  ExportSection *exportSection;
129
};
130

131
class LCSubFramework final : public LoadCommand {
132
public:
133
  LCSubFramework(StringRef umbrella) : umbrella(umbrella) {}
134

135
  uint32_t getSize() const override {
136
    return alignToPowerOf2(sizeof(sub_framework_command) + umbrella.size() + 1,
137
                           target->wordSize);
138
  }
139

140
  void writeTo(uint8_t *buf) const override {
141
    auto *c = reinterpret_cast<sub_framework_command *>(buf);
142
    buf += sizeof(sub_framework_command);
143

144
    c->cmd = LC_SUB_FRAMEWORK;
145
    c->cmdsize = getSize();
146
    c->umbrella = sizeof(sub_framework_command);
147

148
    memcpy(buf, umbrella.data(), umbrella.size());
149
    buf[umbrella.size()] = '\0';
150
  }
151

152
private:
153
  const StringRef umbrella;
154
};
155

156
class LCFunctionStarts final : public LoadCommand {
157
public:
158
  explicit LCFunctionStarts(FunctionStartsSection *functionStartsSection)
159
      : functionStartsSection(functionStartsSection) {}
160

161
  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
162

163
  void writeTo(uint8_t *buf) const override {
164
    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
165
    c->cmd = LC_FUNCTION_STARTS;
166
    c->cmdsize = getSize();
167
    c->dataoff = functionStartsSection->fileOff;
168
    c->datasize = functionStartsSection->getFileSize();
169
  }
170

171
private:
172
  FunctionStartsSection *functionStartsSection;
173
};
174

175
class LCDataInCode final : public LoadCommand {
176
public:
177
  explicit LCDataInCode(DataInCodeSection *dataInCodeSection)
178
      : dataInCodeSection(dataInCodeSection) {}
179

180
  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
181

182
  void writeTo(uint8_t *buf) const override {
183
    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
184
    c->cmd = LC_DATA_IN_CODE;
185
    c->cmdsize = getSize();
186
    c->dataoff = dataInCodeSection->fileOff;
187
    c->datasize = dataInCodeSection->getFileSize();
188
  }
189

190
private:
191
  DataInCodeSection *dataInCodeSection;
192
};
193

194
class LCDysymtab final : public LoadCommand {
195
public:
196
  LCDysymtab(SymtabSection *symtabSection,
197
             IndirectSymtabSection *indirectSymtabSection)
198
      : symtabSection(symtabSection),
199
        indirectSymtabSection(indirectSymtabSection) {}
200

201
  uint32_t getSize() const override { return sizeof(dysymtab_command); }
202

203
  void writeTo(uint8_t *buf) const override {
204
    auto *c = reinterpret_cast<dysymtab_command *>(buf);
205
    c->cmd = LC_DYSYMTAB;
206
    c->cmdsize = getSize();
207

208
    c->ilocalsym = 0;
209
    c->iextdefsym = c->nlocalsym = symtabSection->getNumLocalSymbols();
210
    c->nextdefsym = symtabSection->getNumExternalSymbols();
211
    c->iundefsym = c->iextdefsym + c->nextdefsym;
212
    c->nundefsym = symtabSection->getNumUndefinedSymbols();
213

214
    c->indirectsymoff = indirectSymtabSection->fileOff;
215
    c->nindirectsyms = indirectSymtabSection->getNumSymbols();
216
  }
217

218
  SymtabSection *symtabSection;
219
  IndirectSymtabSection *indirectSymtabSection;
220
};
221

222
template <class LP> class LCSegment final : public LoadCommand {
223
public:
224
  LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {}
225

226
  uint32_t getSize() const override {
227
    return sizeof(typename LP::segment_command) +
228
           seg->numNonHiddenSections() * sizeof(typename LP::section);
229
  }
230

231
  void writeTo(uint8_t *buf) const override {
232
    using SegmentCommand = typename LP::segment_command;
233
    using SectionHeader = typename LP::section;
234

235
    auto *c = reinterpret_cast<SegmentCommand *>(buf);
236
    buf += sizeof(SegmentCommand);
237

238
    c->cmd = LP::segmentLCType;
239
    c->cmdsize = getSize();
240
    memcpy(c->segname, name.data(), name.size());
241
    c->fileoff = seg->fileOff;
242
    c->maxprot = seg->maxProt;
243
    c->initprot = seg->initProt;
244

245
    c->vmaddr = seg->addr;
246
    c->vmsize = seg->vmSize;
247
    c->filesize = seg->fileSize;
248
    c->nsects = seg->numNonHiddenSections();
249
    c->flags = seg->flags;
250

251
    for (const OutputSection *osec : seg->getSections()) {
252
      if (osec->isHidden())
253
        continue;
254

255
      auto *sectHdr = reinterpret_cast<SectionHeader *>(buf);
256
      buf += sizeof(SectionHeader);
257

258
      memcpy(sectHdr->sectname, osec->name.data(), osec->name.size());
259
      memcpy(sectHdr->segname, name.data(), name.size());
260

261
      sectHdr->addr = osec->addr;
262
      sectHdr->offset = osec->fileOff;
263
      sectHdr->align = Log2_32(osec->align);
264
      sectHdr->flags = osec->flags;
265
      sectHdr->size = osec->getSize();
266
      sectHdr->reserved1 = osec->reserved1;
267
      sectHdr->reserved2 = osec->reserved2;
268
    }
269
  }
270

271
private:
272
  StringRef name;
273
  OutputSegment *seg;
274
};
275

276
class LCMain final : public LoadCommand {
277
  uint32_t getSize() const override {
278
    return sizeof(structs::entry_point_command);
279
  }
280

281
  void writeTo(uint8_t *buf) const override {
282
    auto *c = reinterpret_cast<structs::entry_point_command *>(buf);
283
    c->cmd = LC_MAIN;
284
    c->cmdsize = getSize();
285

286
    if (config->entry->isInStubs())
287
      c->entryoff =
288
          in.stubs->fileOff + config->entry->stubsIndex * target->stubSize;
289
    else
290
      c->entryoff = config->entry->getVA() - in.header->addr;
291

292
    c->stacksize = 0;
293
  }
294
};
295

296
class LCSymtab final : public LoadCommand {
297
public:
298
  LCSymtab(SymtabSection *symtabSection, StringTableSection *stringTableSection)
299
      : symtabSection(symtabSection), stringTableSection(stringTableSection) {}
300

301
  uint32_t getSize() const override { return sizeof(symtab_command); }
302

303
  void writeTo(uint8_t *buf) const override {
304
    auto *c = reinterpret_cast<symtab_command *>(buf);
305
    c->cmd = LC_SYMTAB;
306
    c->cmdsize = getSize();
307
    c->symoff = symtabSection->fileOff;
308
    c->nsyms = symtabSection->getNumSymbols();
309
    c->stroff = stringTableSection->fileOff;
310
    c->strsize = stringTableSection->getFileSize();
311
  }
312

313
  SymtabSection *symtabSection = nullptr;
314
  StringTableSection *stringTableSection = nullptr;
315
};
316

317
// There are several dylib load commands that share the same structure:
318
//   * LC_LOAD_DYLIB
319
//   * LC_ID_DYLIB
320
//   * LC_REEXPORT_DYLIB
321
class LCDylib final : public LoadCommand {
322
public:
323
  LCDylib(LoadCommandType type, StringRef path,
324
          uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0)
325
      : type(type), path(path), compatibilityVersion(compatibilityVersion),
326
        currentVersion(currentVersion) {
327
    instanceCount++;
328
  }
329

330
  uint32_t getSize() const override {
331
    return alignToPowerOf2(sizeof(dylib_command) + path.size() + 1,
332
                           target->wordSize);
333
  }
334

335
  void writeTo(uint8_t *buf) const override {
336
    auto *c = reinterpret_cast<dylib_command *>(buf);
337
    buf += sizeof(dylib_command);
338

339
    c->cmd = type;
340
    c->cmdsize = getSize();
341
    c->dylib.name = sizeof(dylib_command);
342
    c->dylib.timestamp = 0;
343
    c->dylib.compatibility_version = compatibilityVersion;
344
    c->dylib.current_version = currentVersion;
345

346
    memcpy(buf, path.data(), path.size());
347
    buf[path.size()] = '\0';
348
  }
349

350
  static uint32_t getInstanceCount() { return instanceCount; }
351
  static void resetInstanceCount() { instanceCount = 0; }
352

353
private:
354
  LoadCommandType type;
355
  StringRef path;
356
  uint32_t compatibilityVersion;
357
  uint32_t currentVersion;
358
  static uint32_t instanceCount;
359
};
360

361
uint32_t LCDylib::instanceCount = 0;
362

363
class LCLoadDylinker final : public LoadCommand {
364
public:
365
  uint32_t getSize() const override {
366
    return alignToPowerOf2(sizeof(dylinker_command) + path.size() + 1,
367
                           target->wordSize);
368
  }
369

370
  void writeTo(uint8_t *buf) const override {
371
    auto *c = reinterpret_cast<dylinker_command *>(buf);
372
    buf += sizeof(dylinker_command);
373

374
    c->cmd = LC_LOAD_DYLINKER;
375
    c->cmdsize = getSize();
376
    c->name = sizeof(dylinker_command);
377

378
    memcpy(buf, path.data(), path.size());
379
    buf[path.size()] = '\0';
380
  }
381

382
private:
383
  // Recent versions of Darwin won't run any binary that has dyld at a
384
  // different location.
385
  const StringRef path = "/usr/lib/dyld";
386
};
387

388
class LCRPath final : public LoadCommand {
389
public:
390
  explicit LCRPath(StringRef path) : path(path) {}
391

392
  uint32_t getSize() const override {
393
    return alignToPowerOf2(sizeof(rpath_command) + path.size() + 1,
394
                           target->wordSize);
395
  }
396

397
  void writeTo(uint8_t *buf) const override {
398
    auto *c = reinterpret_cast<rpath_command *>(buf);
399
    buf += sizeof(rpath_command);
400

401
    c->cmd = LC_RPATH;
402
    c->cmdsize = getSize();
403
    c->path = sizeof(rpath_command);
404

405
    memcpy(buf, path.data(), path.size());
406
    buf[path.size()] = '\0';
407
  }
408

409
private:
410
  StringRef path;
411
};
412

413
class LCDyldEnv final : public LoadCommand {
414
public:
415
  explicit LCDyldEnv(StringRef name) : name(name) {}
416

417
  uint32_t getSize() const override {
418
    return alignToPowerOf2(sizeof(dyld_env_command) + name.size() + 1,
419
                           target->wordSize);
420
  }
421

422
  void writeTo(uint8_t *buf) const override {
423
    auto *c = reinterpret_cast<dyld_env_command *>(buf);
424
    buf += sizeof(dyld_env_command);
425

426
    c->cmd = LC_DYLD_ENVIRONMENT;
427
    c->cmdsize = getSize();
428
    c->name = sizeof(dyld_env_command);
429

430
    memcpy(buf, name.data(), name.size());
431
    buf[name.size()] = '\0';
432
  }
433

434
private:
435
  StringRef name;
436
};
437

438
class LCMinVersion final : public LoadCommand {
439
public:
440
  explicit LCMinVersion(const PlatformInfo &platformInfo)
441
      : platformInfo(platformInfo) {}
442

443
  uint32_t getSize() const override { return sizeof(version_min_command); }
444

445
  void writeTo(uint8_t *buf) const override {
446
    auto *c = reinterpret_cast<version_min_command *>(buf);
447
    switch (platformInfo.target.Platform) {
448
    case PLATFORM_MACOS:
449
      c->cmd = LC_VERSION_MIN_MACOSX;
450
      break;
451
    case PLATFORM_IOS:
452
    case PLATFORM_IOSSIMULATOR:
453
      c->cmd = LC_VERSION_MIN_IPHONEOS;
454
      break;
455
    case PLATFORM_TVOS:
456
    case PLATFORM_TVOSSIMULATOR:
457
      c->cmd = LC_VERSION_MIN_TVOS;
458
      break;
459
    case PLATFORM_WATCHOS:
460
    case PLATFORM_WATCHOSSIMULATOR:
461
      c->cmd = LC_VERSION_MIN_WATCHOS;
462
      break;
463
    default:
464
      llvm_unreachable("invalid platform");
465
      break;
466
    }
467
    c->cmdsize = getSize();
468
    c->version = encodeVersion(platformInfo.target.MinDeployment);
469
    c->sdk = encodeVersion(platformInfo.sdk);
470
  }
471

472
private:
473
  const PlatformInfo &platformInfo;
474
};
475

476
class LCBuildVersion final : public LoadCommand {
477
public:
478
  explicit LCBuildVersion(const PlatformInfo &platformInfo)
479
      : platformInfo(platformInfo) {}
480

481
  const int ntools = 1;
482

483
  uint32_t getSize() const override {
484
    return sizeof(build_version_command) + ntools * sizeof(build_tool_version);
485
  }
486

487
  void writeTo(uint8_t *buf) const override {
488
    auto *c = reinterpret_cast<build_version_command *>(buf);
489
    c->cmd = LC_BUILD_VERSION;
490
    c->cmdsize = getSize();
491

492
    c->platform = static_cast<uint32_t>(platformInfo.target.Platform);
493
    c->minos = encodeVersion(platformInfo.target.MinDeployment);
494
    c->sdk = encodeVersion(platformInfo.sdk);
495

496
    c->ntools = ntools;
497
    auto *t = reinterpret_cast<build_tool_version *>(&c[1]);
498
    t->tool = TOOL_LLD;
499
    t->version = encodeVersion(VersionTuple(
500
        LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR, LLVM_VERSION_PATCH));
501
  }
502

503
private:
504
  const PlatformInfo &platformInfo;
505
};
506

507
// Stores a unique identifier for the output file based on an MD5 hash of its
508
// contents. In order to hash the contents, we must first write them, but
509
// LC_UUID itself must be part of the written contents in order for all the
510
// offsets to be calculated correctly. We resolve this circular paradox by
511
// first writing an LC_UUID with an all-zero UUID, then updating the UUID with
512
// its real value later.
513
class LCUuid final : public LoadCommand {
514
public:
515
  uint32_t getSize() const override { return sizeof(uuid_command); }
516

517
  void writeTo(uint8_t *buf) const override {
518
    auto *c = reinterpret_cast<uuid_command *>(buf);
519
    c->cmd = LC_UUID;
520
    c->cmdsize = getSize();
521
    uuidBuf = c->uuid;
522
  }
523

524
  void writeUuid(uint64_t digest) const {
525
    // xxhash only gives us 8 bytes, so put some fixed data in the other half.
526
    static_assert(sizeof(uuid_command::uuid) == 16, "unexpected uuid size");
527
    memcpy(uuidBuf, "LLD\xa1UU1D", 8);
528
    memcpy(uuidBuf + 8, &digest, 8);
529

530
    // RFC 4122 conformance. We need to fix 4 bits in byte 6 and 2 bits in
531
    // byte 8. Byte 6 is already fine due to the fixed data we put in. We don't
532
    // want to lose bits of the digest in byte 8, so swap that with a byte of
533
    // fixed data that happens to have the right bits set.
534
    std::swap(uuidBuf[3], uuidBuf[8]);
535

536
    // Claim that this is an MD5-based hash. It isn't, but this signals that
537
    // this is not a time-based and not a random hash. MD5 seems like the least
538
    // bad lie we can put here.
539
    assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3");
540
    assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 Section 4.2.2");
541
  }
542

543
  mutable uint8_t *uuidBuf;
544
};
545

546
template <class LP> class LCEncryptionInfo final : public LoadCommand {
547
public:
548
  uint32_t getSize() const override {
549
    return sizeof(typename LP::encryption_info_command);
550
  }
551

552
  void writeTo(uint8_t *buf) const override {
553
    using EncryptionInfo = typename LP::encryption_info_command;
554
    auto *c = reinterpret_cast<EncryptionInfo *>(buf);
555
    buf += sizeof(EncryptionInfo);
556
    c->cmd = LP::encryptionInfoLCType;
557
    c->cmdsize = getSize();
558
    c->cryptoff = in.header->getSize();
559
    auto it = find_if(outputSegments, [](const OutputSegment *seg) {
560
      return seg->name == segment_names::text;
561
    });
562
    assert(it != outputSegments.end());
563
    c->cryptsize = (*it)->fileSize - c->cryptoff;
564
  }
565
};
566

567
class LCCodeSignature final : public LoadCommand {
568
public:
569
  LCCodeSignature(CodeSignatureSection *section) : section(section) {}
570

571
  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
572

573
  void writeTo(uint8_t *buf) const override {
574
    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
575
    c->cmd = LC_CODE_SIGNATURE;
576
    c->cmdsize = getSize();
577
    c->dataoff = static_cast<uint32_t>(section->fileOff);
578
    c->datasize = section->getSize();
579
  }
580

581
  CodeSignatureSection *section;
582
};
583

584
class LCExportsTrie final : public LoadCommand {
585
public:
586
  LCExportsTrie(ExportSection *section) : section(section) {}
587

588
  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
589

590
  void writeTo(uint8_t *buf) const override {
591
    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
592
    c->cmd = LC_DYLD_EXPORTS_TRIE;
593
    c->cmdsize = getSize();
594
    c->dataoff = section->fileOff;
595
    c->datasize = section->getSize();
596
  }
597

598
  ExportSection *section;
599
};
600

601
class LCChainedFixups final : public LoadCommand {
602
public:
603
  LCChainedFixups(ChainedFixupsSection *section) : section(section) {}
604

605
  uint32_t getSize() const override { return sizeof(linkedit_data_command); }
606

607
  void writeTo(uint8_t *buf) const override {
608
    auto *c = reinterpret_cast<linkedit_data_command *>(buf);
609
    c->cmd = LC_DYLD_CHAINED_FIXUPS;
610
    c->cmdsize = getSize();
611
    c->dataoff = section->fileOff;
612
    c->datasize = section->getSize();
613
  }
614

615
  ChainedFixupsSection *section;
616
};
617

618
} // namespace
619

620
void Writer::treatSpecialUndefineds() {
621
  if (config->entry)
622
    if (auto *undefined = dyn_cast<Undefined>(config->entry))
623
      treatUndefinedSymbol(*undefined, "the entry point");
624

625
  // FIXME: This prints symbols that are undefined both in input files and
626
  // via -u flag twice.
627
  for (const Symbol *sym : config->explicitUndefineds) {
628
    if (const auto *undefined = dyn_cast<Undefined>(sym))
629
      treatUndefinedSymbol(*undefined, "-u");
630
  }
631
  // Literal exported-symbol names must be defined, but glob
632
  // patterns need not match.
633
  for (const CachedHashStringRef &cachedName :
634
       config->exportedSymbols.literals) {
635
    if (const Symbol *sym = symtab->find(cachedName))
636
      if (const auto *undefined = dyn_cast<Undefined>(sym))
637
        treatUndefinedSymbol(*undefined, "-exported_symbol(s_list)");
638
  }
639
}
640

641
static void prepareSymbolRelocation(Symbol *sym, const InputSection *isec,
642
                                    const lld::macho::Reloc &r) {
643
  if (!sym->isLive()) {
644
    if (Defined *defined = dyn_cast<Defined>(sym)) {
645
      if (config->emitInitOffsets &&
646
          defined->isec()->getName() == section_names::moduleInitFunc)
647
        fatal(isec->getLocation(r.offset) + ": cannot reference " +
648
              sym->getName() +
649
              " defined in __mod_init_func when -init_offsets is used");
650
    }
651
    assert(false && "referenced symbol must be live");
652
  }
653

654
  const RelocAttrs &relocAttrs = target->getRelocAttrs(r.type);
655

656
  if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
657
    if (needsBinding(sym))
658
      in.stubs->addEntry(sym);
659
  } else if (relocAttrs.hasAttr(RelocAttrBits::GOT)) {
660
    if (relocAttrs.hasAttr(RelocAttrBits::POINTER) || needsBinding(sym))
661
      in.got->addEntry(sym);
662
  } else if (relocAttrs.hasAttr(RelocAttrBits::TLV)) {
663
    if (needsBinding(sym))
664
      in.tlvPointers->addEntry(sym);
665
  } else if (relocAttrs.hasAttr(RelocAttrBits::UNSIGNED)) {
666
    // References from thread-local variable sections are treated as offsets
667
    // relative to the start of the referent section, and therefore have no
668
    // need of rebase opcodes.
669
    if (!(isThreadLocalVariables(isec->getFlags()) && isa<Defined>(sym)))
670
      addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
671
  }
672
}
673

674
void Writer::scanRelocations() {
675
  TimeTraceScope timeScope("Scan relocations");
676

677
  // This can't use a for-each loop: It calls treatUndefinedSymbol(), which can
678
  // add to inputSections, which invalidates inputSections's iterators.
679
  for (size_t i = 0; i < inputSections.size(); ++i) {
680
    ConcatInputSection *isec = inputSections[i];
681

682
    if (isec->shouldOmitFromOutput())
683
      continue;
684

685
    for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
686
      lld::macho::Reloc &r = *it;
687

688
      // Canonicalize the referent so that later accesses in Writer won't
689
      // have to worry about it.
690
      if (auto *referentIsec = r.referent.dyn_cast<InputSection *>())
691
        r.referent = referentIsec->canonical();
692

693
      if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
694
        // Skip over the following UNSIGNED relocation -- it's just there as the
695
        // minuend, and doesn't have the usual UNSIGNED semantics. We don't want
696
        // to emit rebase opcodes for it.
697
        ++it;
698
        // Canonicalize the referent so that later accesses in Writer won't
699
        // have to worry about it.
700
        if (auto *referentIsec = it->referent.dyn_cast<InputSection *>())
701
          it->referent = referentIsec->canonical();
702
        continue;
703
      }
704
      if (auto *sym = r.referent.dyn_cast<Symbol *>()) {
705
        if (auto *undefined = dyn_cast<Undefined>(sym))
706
          treatUndefinedSymbol(*undefined, isec, r.offset);
707
        // treatUndefinedSymbol() can replace sym with a DylibSymbol; re-check.
708
        if (!isa<Undefined>(sym) && validateSymbolRelocation(sym, isec, r))
709
          prepareSymbolRelocation(sym, isec, r);
710
      } else {
711
        if (!r.pcrel) {
712
          if (config->emitChainedFixups)
713
            in.chainedFixups->addRebase(isec, r.offset);
714
          else
715
            in.rebase->addEntry(isec, r.offset);
716
        }
717
      }
718
    }
719
  }
720

721
  in.unwindInfo->prepare();
722
}
723

724
static void addNonWeakDefinition(const Defined *defined) {
725
  if (config->emitChainedFixups)
726
    in.chainedFixups->setHasNonWeakDefinition();
727
  else
728
    in.weakBinding->addNonWeakDefinition(defined);
729
}
730

731
void Writer::scanSymbols() {
732
  TimeTraceScope timeScope("Scan symbols");
733
  ObjCSelRefsHelper::initialize();
734
  for (Symbol *sym : symtab->getSymbols()) {
735
    if (auto *defined = dyn_cast<Defined>(sym)) {
736
      if (!defined->isLive())
737
        continue;
738
      if (defined->overridesWeakDef)
739
        addNonWeakDefinition(defined);
740
      if (!defined->isAbsolute() && isCodeSection(defined->isec()))
741
        in.unwindInfo->addSymbol(defined);
742
    } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
743
      // This branch intentionally doesn't check isLive().
744
      if (dysym->isDynamicLookup())
745
        continue;
746
      dysym->getFile()->refState =
747
          std::max(dysym->getFile()->refState, dysym->getRefState());
748
    } else if (isa<Undefined>(sym)) {
749
      if (ObjCStubsSection::isObjCStubSymbol(sym)) {
750
        // When -dead_strip is enabled, we don't want to emit any dead stubs.
751
        // Although this stub symbol is yet undefined, addSym() was called
752
        // during MarkLive.
753
        if (config->deadStrip) {
754
          if (!sym->isLive())
755
            continue;
756
        }
757
        in.objcStubs->addEntry(sym);
758
      }
759
    }
760
  }
761

762
  for (const InputFile *file : inputFiles) {
763
    if (auto *objFile = dyn_cast<ObjFile>(file))
764
      for (Symbol *sym : objFile->symbols) {
765
        if (auto *defined = dyn_cast_or_null<Defined>(sym)) {
766
          if (!defined->isLive())
767
            continue;
768
          if (!defined->isExternal() && !defined->isAbsolute() &&
769
              isCodeSection(defined->isec()))
770
            in.unwindInfo->addSymbol(defined);
771
        }
772
      }
773
  }
774
}
775

776
// TODO: ld64 enforces the old load commands in a few other cases.
777
static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
778
  static const std::array<std::pair<PlatformType, VersionTuple>, 7> minVersion =
779
      {{{PLATFORM_MACOS, VersionTuple(10, 14)},
780
        {PLATFORM_IOS, VersionTuple(12, 0)},
781
        {PLATFORM_IOSSIMULATOR, VersionTuple(13, 0)},
782
        {PLATFORM_TVOS, VersionTuple(12, 0)},
783
        {PLATFORM_TVOSSIMULATOR, VersionTuple(13, 0)},
784
        {PLATFORM_WATCHOS, VersionTuple(5, 0)},
785
        {PLATFORM_WATCHOSSIMULATOR, VersionTuple(6, 0)}}};
786
  auto it = llvm::find_if(minVersion, [&](const auto &p) {
787
    return p.first == platformInfo.target.Platform;
788
  });
789
  return it == minVersion.end()
790
             ? true
791
             : platformInfo.target.MinDeployment >= it->second;
792
}
793

794
template <class LP> void Writer::createLoadCommands() {
795
  uint8_t segIndex = 0;
796
  for (OutputSegment *seg : outputSegments) {
797
    in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
798
    seg->index = segIndex++;
799
  }
800

801
  if (config->emitChainedFixups) {
802
    in.header->addLoadCommand(make<LCChainedFixups>(in.chainedFixups));
803
    in.header->addLoadCommand(make<LCExportsTrie>(in.exports));
804
  } else {
805
    in.header->addLoadCommand(make<LCDyldInfo>(
806
        in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports));
807
  }
808
  in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
809
  in.header->addLoadCommand(
810
      make<LCDysymtab>(symtabSection, indirectSymtabSection));
811
  if (!config->umbrella.empty())
812
    in.header->addLoadCommand(make<LCSubFramework>(config->umbrella));
813
  if (config->emitEncryptionInfo)
814
    in.header->addLoadCommand(make<LCEncryptionInfo<LP>>());
815
  for (StringRef path : config->runtimePaths)
816
    in.header->addLoadCommand(make<LCRPath>(path));
817

818
  switch (config->outputType) {
819
  case MH_EXECUTE:
820
    in.header->addLoadCommand(make<LCLoadDylinker>());
821
    break;
822
  case MH_DYLIB:
823
    in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
824
                                            config->dylibCompatibilityVersion,
825
                                            config->dylibCurrentVersion));
826
    break;
827
  case MH_BUNDLE:
828
    break;
829
  default:
830
    llvm_unreachable("unhandled output file type");
831
  }
832

833
  if (config->generateUuid) {
834
    uuidCommand = make<LCUuid>();
835
    in.header->addLoadCommand(uuidCommand);
836
  }
837

838
  if (useLCBuildVersion(config->platformInfo))
839
    in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo));
840
  else
841
    in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo));
842

843
  if (config->secondaryPlatformInfo) {
844
    in.header->addLoadCommand(
845
        make<LCBuildVersion>(*config->secondaryPlatformInfo));
846
  }
847

848
  // This is down here to match ld64's load command order.
849
  if (config->outputType == MH_EXECUTE)
850
    in.header->addLoadCommand(make<LCMain>());
851

852
  // See ld64's OutputFile::buildDylibOrdinalMapping for the corresponding
853
  // library ordinal computation code in ld64.
854
  int64_t dylibOrdinal = 1;
855
  DenseMap<StringRef, int64_t> ordinalForInstallName;
856

857
  std::vector<DylibFile *> dylibFiles;
858
  for (InputFile *file : inputFiles) {
859
    if (auto *dylibFile = dyn_cast<DylibFile>(file))
860
      dylibFiles.push_back(dylibFile);
861
  }
862
  for (size_t i = 0; i < dylibFiles.size(); ++i)
863
    dylibFiles.insert(dylibFiles.end(), dylibFiles[i]->extraDylibs.begin(),
864
                      dylibFiles[i]->extraDylibs.end());
865

866
  for (DylibFile *dylibFile : dylibFiles) {
867
    if (dylibFile->isBundleLoader) {
868
      dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
869
      // Shortcut since bundle-loader does not re-export the symbols.
870

871
      dylibFile->reexport = false;
872
      continue;
873
    }
874

875
    // Don't emit load commands for a dylib that is not referenced if:
876
    // - it was added implicitly (via a reexport, an LC_LOAD_DYLINKER --
877
    //   if it's on the linker command line, it's explicit)
878
    // - or it's marked MH_DEAD_STRIPPABLE_DYLIB
879
    // - or the flag -dead_strip_dylibs is used
880
    // FIXME: `isReferenced()` is currently computed before dead code
881
    // stripping, so references from dead code keep a dylib alive. This
882
    // matches ld64, but it's something we should do better.
883
    if (!dylibFile->isReferenced() && !dylibFile->forceNeeded &&
884
        (!dylibFile->isExplicitlyLinked() || dylibFile->deadStrippable ||
885
         config->deadStripDylibs))
886
      continue;
887

888
    // Several DylibFiles can have the same installName. Only emit a single
889
    // load command for that installName and give all these DylibFiles the
890
    // same ordinal.
891
    // This can happen in several cases:
892
    // - a new framework could change its installName to an older
893
    //   framework name via an $ld$ symbol depending on platform_version
894
    // - symlinks (for example, libpthread.tbd is a symlink to libSystem.tbd;
895
    //   Foo.framework/Foo.tbd is usually a symlink to
896
    //   Foo.framework/Versions/Current/Foo.tbd, where
897
    //   Foo.framework/Versions/Current is usually a symlink to
898
    //   Foo.framework/Versions/A)
899
    // - a framework can be linked both explicitly on the linker
900
    //   command line and implicitly as a reexport from a different
901
    //   framework. The re-export will usually point to the tbd file
902
    //   in Foo.framework/Versions/A/Foo.tbd, while the explicit link will
903
    //   usually find Foo.framework/Foo.tbd. These are usually symlinks,
904
    //   but in a --reproduce archive they will be identical but distinct
905
    //   files.
906
    // In the first case, *semantically distinct* DylibFiles will have the
907
    // same installName.
908
    int64_t &ordinal = ordinalForInstallName[dylibFile->installName];
909
    if (ordinal) {
910
      dylibFile->ordinal = ordinal;
911
      continue;
912
    }
913

914
    ordinal = dylibFile->ordinal = dylibOrdinal++;
915
    LoadCommandType lcType =
916
        dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak
917
            ? LC_LOAD_WEAK_DYLIB
918
            : LC_LOAD_DYLIB;
919
    in.header->addLoadCommand(make<LCDylib>(lcType, dylibFile->installName,
920
                                            dylibFile->compatibilityVersion,
921
                                            dylibFile->currentVersion));
922

923
    if (dylibFile->reexport)
924
      in.header->addLoadCommand(
925
          make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->installName));
926
  }
927

928
  for (const auto &dyldEnv : config->dyldEnvs)
929
    in.header->addLoadCommand(make<LCDyldEnv>(dyldEnv));
930

931
  if (functionStartsSection)
932
    in.header->addLoadCommand(make<LCFunctionStarts>(functionStartsSection));
933
  if (dataInCodeSection)
934
    in.header->addLoadCommand(make<LCDataInCode>(dataInCodeSection));
935
  if (codeSignatureSection)
936
    in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection));
937

938
  const uint32_t MACOS_MAXPATHLEN = 1024;
939
  config->headerPad = std::max(
940
      config->headerPad, (config->headerPadMaxInstallNames
941
                              ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN
942
                              : 0));
943
}
944

945
// Sorting only can happen once all outputs have been collected. Here we sort
946
// segments, output sections within each segment, and input sections within each
947
// output segment.
948
static void sortSegmentsAndSections() {
949
  TimeTraceScope timeScope("Sort segments and sections");
950
  sortOutputSegments();
951

952
  DenseMap<const InputSection *, size_t> isecPriorities =
953
      priorityBuilder.buildInputSectionPriorities();
954

955
  uint32_t sectionIndex = 0;
956
  for (OutputSegment *seg : outputSegments) {
957
    seg->sortOutputSections();
958
    // References from thread-local variable sections are treated as offsets
959
    // relative to the start of the thread-local data memory area, which
960
    // is initialized via copying all the TLV data sections (which are all
961
    // contiguous). If later data sections require a greater alignment than
962
    // earlier ones, the offsets of data within those sections won't be
963
    // guaranteed to aligned unless we normalize alignments. We therefore use
964
    // the largest alignment for all TLV data sections.
965
    uint32_t tlvAlign = 0;
966
    for (const OutputSection *osec : seg->getSections())
967
      if (isThreadLocalData(osec->flags) && osec->align > tlvAlign)
968
        tlvAlign = osec->align;
969

970
    for (OutputSection *osec : seg->getSections()) {
971
      // Now that the output sections are sorted, assign the final
972
      // output section indices.
973
      if (!osec->isHidden())
974
        osec->index = ++sectionIndex;
975
      if (isThreadLocalData(osec->flags)) {
976
        if (!firstTLVDataSection)
977
          firstTLVDataSection = osec;
978
        osec->align = tlvAlign;
979
      }
980

981
      if (!isecPriorities.empty()) {
982
        if (auto *merged = dyn_cast<ConcatOutputSection>(osec)) {
983
          llvm::stable_sort(
984
              merged->inputs, [&](InputSection *a, InputSection *b) {
985
                return isecPriorities.lookup(a) > isecPriorities.lookup(b);
986
              });
987
        }
988
      }
989
    }
990
  }
991
}
992

993
template <class LP> void Writer::createOutputSections() {
994
  TimeTraceScope timeScope("Create output sections");
995
  // First, create hidden sections
996
  stringTableSection = make<StringTableSection>();
997
  symtabSection = makeSymtabSection<LP>(*stringTableSection);
998
  indirectSymtabSection = make<IndirectSymtabSection>();
999
  if (config->adhocCodesign)
1000
    codeSignatureSection = make<CodeSignatureSection>();
1001
  if (config->emitDataInCodeInfo)
1002
    dataInCodeSection = make<DataInCodeSection>();
1003
  if (config->emitFunctionStarts)
1004
    functionStartsSection = make<FunctionStartsSection>();
1005

1006
  switch (config->outputType) {
1007
  case MH_EXECUTE:
1008
    make<PageZeroSection>();
1009
    break;
1010
  case MH_DYLIB:
1011
  case MH_BUNDLE:
1012
    break;
1013
  default:
1014
    llvm_unreachable("unhandled output file type");
1015
  }
1016

1017
  // Then add input sections to output sections.
1018
  for (ConcatInputSection *isec : inputSections) {
1019
    if (isec->shouldOmitFromOutput())
1020
      continue;
1021
    ConcatOutputSection *osec = cast<ConcatOutputSection>(isec->parent);
1022
    osec->addInput(isec);
1023
    osec->inputOrder =
1024
        std::min(osec->inputOrder, static_cast<int>(isec->outSecOff));
1025
  }
1026

1027
  // Once all the inputs are added, we can finalize the output section
1028
  // properties and create the corresponding output segments.
1029
  for (const auto &it : concatOutputSections) {
1030
    StringRef segname = it.first.first;
1031
    ConcatOutputSection *osec = it.second;
1032
    assert(segname != segment_names::ld);
1033
    if (osec->isNeeded()) {
1034
      // See comment in ObjFile::splitEhFrames()
1035
      if (osec->name == section_names::ehFrame &&
1036
          segname == segment_names::text)
1037
        osec->align = target->wordSize;
1038

1039
      // MC keeps the default 1-byte alignment for __thread_vars, even though it
1040
      // contains pointers that are fixed up by dyld, which requires proper
1041
      // alignment.
1042
      if (isThreadLocalVariables(osec->flags))
1043
        osec->align = std::max<uint32_t>(osec->align, target->wordSize);
1044

1045
      getOrCreateOutputSegment(segname)->addOutputSection(osec);
1046
    }
1047
  }
1048

1049
  for (SyntheticSection *ssec : syntheticSections) {
1050
    auto it = concatOutputSections.find({ssec->segname, ssec->name});
1051
    // We add all LinkEdit sections here because we don't know if they are
1052
    // needed until their finalizeContents() methods get called later. While
1053
    // this means that we add some redundant sections to __LINKEDIT, there is
1054
    // is no redundancy in the output, as we do not emit section headers for
1055
    // any LinkEdit sections.
1056
    if (ssec->isNeeded() || ssec->segname == segment_names::linkEdit) {
1057
      if (it == concatOutputSections.end()) {
1058
        getOrCreateOutputSegment(ssec->segname)->addOutputSection(ssec);
1059
      } else {
1060
        fatal("section from " +
1061
              toString(it->second->firstSection()->getFile()) +
1062
              " conflicts with synthetic section " + ssec->segname + "," +
1063
              ssec->name);
1064
      }
1065
    }
1066
  }
1067

1068
  // dyld requires __LINKEDIT segment to always exist (even if empty).
1069
  linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit);
1070
}
1071

1072
void Writer::finalizeAddresses() {
1073
  TimeTraceScope timeScope("Finalize addresses");
1074
  uint64_t pageSize = target->getPageSize();
1075

1076
  // We could parallelize this loop, but local benchmarking indicates it is
1077
  // faster to do it all in the main thread.
1078
  for (OutputSegment *seg : outputSegments) {
1079
    if (seg == linkEditSegment)
1080
      continue;
1081
    for (OutputSection *osec : seg->getSections()) {
1082
      if (!osec->isNeeded())
1083
        continue;
1084
      // Other kinds of OutputSections have already been finalized.
1085
      if (auto *concatOsec = dyn_cast<ConcatOutputSection>(osec))
1086
        concatOsec->finalizeContents();
1087
    }
1088
  }
1089

1090
  // Ensure that segments (and the sections they contain) are allocated
1091
  // addresses in ascending order, which dyld requires.
1092
  //
1093
  // Note that at this point, __LINKEDIT sections are empty, but we need to
1094
  // determine addresses of other segments/sections before generating its
1095
  // contents.
1096
  for (OutputSegment *seg : outputSegments) {
1097
    if (seg == linkEditSegment)
1098
      continue;
1099
    seg->addr = addr;
1100
    assignAddresses(seg);
1101
    // codesign / libstuff checks for segment ordering by verifying that
1102
    // `fileOff + fileSize == next segment fileOff`. So we call
1103
    // alignToPowerOf2() before (instead of after) computing fileSize to ensure
1104
    // that the segments are contiguous. We handle addr / vmSize similarly for
1105
    // the same reason.
1106
    fileOff = alignToPowerOf2(fileOff, pageSize);
1107
    addr = alignToPowerOf2(addr, pageSize);
1108
    seg->vmSize = addr - seg->addr;
1109
    seg->fileSize = fileOff - seg->fileOff;
1110
    seg->assignAddressesToStartEndSymbols();
1111
  }
1112
}
1113

1114
void Writer::finalizeLinkEditSegment() {
1115
  TimeTraceScope timeScope("Finalize __LINKEDIT segment");
1116
  // Fill __LINKEDIT contents.
1117
  std::array<LinkEditSection *, 10> linkEditSections{
1118
      in.rebase,         in.binding,
1119
      in.weakBinding,    in.lazyBinding,
1120
      in.exports,        in.chainedFixups,
1121
      symtabSection,     indirectSymtabSection,
1122
      dataInCodeSection, functionStartsSection,
1123
  };
1124
  SmallVector<std::shared_future<void>> threadFutures;
1125
  threadFutures.reserve(linkEditSections.size());
1126
  for (LinkEditSection *osec : linkEditSections)
1127
    if (osec)
1128
      threadFutures.emplace_back(threadPool.async(
1129
          [](LinkEditSection *osec) { osec->finalizeContents(); }, osec));
1130
  for (std::shared_future<void> &future : threadFutures)
1131
    future.wait();
1132

1133
  // Now that __LINKEDIT is filled out, do a proper calculation of its
1134
  // addresses and offsets.
1135
  linkEditSegment->addr = addr;
1136
  assignAddresses(linkEditSegment);
1137
  // No need to page-align fileOff / addr here since this is the last segment.
1138
  linkEditSegment->vmSize = addr - linkEditSegment->addr;
1139
  linkEditSegment->fileSize = fileOff - linkEditSegment->fileOff;
1140
}
1141

1142
void Writer::assignAddresses(OutputSegment *seg) {
1143
  seg->fileOff = fileOff;
1144

1145
  for (OutputSection *osec : seg->getSections()) {
1146
    if (!osec->isNeeded())
1147
      continue;
1148
    addr = alignToPowerOf2(addr, osec->align);
1149
    fileOff = alignToPowerOf2(fileOff, osec->align);
1150
    osec->addr = addr;
1151
    osec->fileOff = isZeroFill(osec->flags) ? 0 : fileOff;
1152
    osec->finalize();
1153
    osec->assignAddressesToStartEndSymbols();
1154

1155
    addr += osec->getSize();
1156
    fileOff += osec->getFileSize();
1157
  }
1158
}
1159

1160
void Writer::openFile() {
1161
  Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
1162
      FileOutputBuffer::create(config->outputFile, fileOff,
1163
                               FileOutputBuffer::F_executable);
1164

1165
  if (!bufferOrErr)
1166
    fatal("failed to open " + config->outputFile + ": " +
1167
          llvm::toString(bufferOrErr.takeError()));
1168
  buffer = std::move(*bufferOrErr);
1169
  in.bufferStart = buffer->getBufferStart();
1170
}
1171

1172
void Writer::writeSections() {
1173
  uint8_t *buf = buffer->getBufferStart();
1174
  std::vector<const OutputSection *> osecs;
1175
  for (const OutputSegment *seg : outputSegments)
1176
    append_range(osecs, seg->getSections());
1177

1178
  parallelForEach(osecs.begin(), osecs.end(), [&](const OutputSection *osec) {
1179
    osec->writeTo(buf + osec->fileOff);
1180
  });
1181
}
1182

1183
void Writer::applyOptimizationHints() {
1184
  if (config->arch() != AK_arm64 || config->ignoreOptimizationHints)
1185
    return;
1186

1187
  uint8_t *buf = buffer->getBufferStart();
1188
  TimeTraceScope timeScope("Apply linker optimization hints");
1189
  parallelForEach(inputFiles, [buf](const InputFile *file) {
1190
    if (const auto *objFile = dyn_cast<ObjFile>(file))
1191
      target->applyOptimizationHints(buf, *objFile);
1192
  });
1193
}
1194

1195
// In order to utilize multiple cores, we first split the buffer into chunks,
1196
// compute a hash for each chunk, and then compute a hash value of the hash
1197
// values.
1198
void Writer::writeUuid() {
1199
  TimeTraceScope timeScope("Computing UUID");
1200

1201
  ArrayRef<uint8_t> data{buffer->getBufferStart(), buffer->getBufferEnd()};
1202
  std::vector<ArrayRef<uint8_t>> chunks = split(data, 1024 * 1024);
1203
  // Leave one slot for filename
1204
  std::vector<uint64_t> hashes(chunks.size() + 1);
1205
  SmallVector<std::shared_future<void>> threadFutures;
1206
  threadFutures.reserve(chunks.size());
1207
  for (size_t i = 0; i < chunks.size(); ++i)
1208
    threadFutures.emplace_back(threadPool.async(
1209
        [&](size_t j) { hashes[j] = xxh3_64bits(chunks[j]); }, i));
1210
  for (std::shared_future<void> &future : threadFutures)
1211
    future.wait();
1212
  // Append the output filename so that identical binaries with different names
1213
  // don't get the same UUID.
1214
  hashes[chunks.size()] = xxh3_64bits(sys::path::filename(config->finalOutput));
1215
  uint64_t digest = xxh3_64bits({reinterpret_cast<uint8_t *>(hashes.data()),
1216
                                 hashes.size() * sizeof(uint64_t)});
1217
  uuidCommand->writeUuid(digest);
1218
}
1219

1220
// This is step 5 of the algorithm described in the class comment of
1221
// ChainedFixupsSection.
1222
void Writer::buildFixupChains() {
1223
  if (!config->emitChainedFixups)
1224
    return;
1225

1226
  const std::vector<Location> &loc = in.chainedFixups->getLocations();
1227
  if (loc.empty())
1228
    return;
1229

1230
  TimeTraceScope timeScope("Build fixup chains");
1231

1232
  const uint64_t pageSize = target->getPageSize();
1233
  constexpr uint32_t stride = 4; // for DYLD_CHAINED_PTR_64
1234

1235
  for (size_t i = 0, count = loc.size(); i < count;) {
1236
    const OutputSegment *oseg = loc[i].isec->parent->parent;
1237
    uint8_t *buf = buffer->getBufferStart() + oseg->fileOff;
1238
    uint64_t pageIdx = loc[i].offset / pageSize;
1239
    ++i;
1240

1241
    while (i < count && loc[i].isec->parent->parent == oseg &&
1242
           (loc[i].offset / pageSize) == pageIdx) {
1243
      uint64_t offset = loc[i].offset - loc[i - 1].offset;
1244

1245
      auto fail = [&](Twine message) {
1246
        error(loc[i].isec->getSegName() + "," + loc[i].isec->getName() +
1247
              ", offset " +
1248
              Twine(loc[i].offset - loc[i].isec->parent->getSegmentOffset()) +
1249
              ": " + message);
1250
      };
1251

1252
      if (offset < target->wordSize)
1253
        return fail("fixups overlap");
1254
      if (offset % stride != 0)
1255
        return fail(
1256
            "fixups are unaligned (offset " + Twine(offset) +
1257
            " is not a multiple of the stride). Re-link with -no_fixup_chains");
1258

1259
      // The "next" field is in the same location for bind and rebase entries.
1260
      reinterpret_cast<dyld_chained_ptr_64_bind *>(buf + loc[i - 1].offset)
1261
          ->next = offset / stride;
1262
      ++i;
1263
    }
1264
  }
1265
}
1266

1267
void Writer::writeCodeSignature() {
1268
  if (codeSignatureSection) {
1269
    TimeTraceScope timeScope("Write code signature");
1270
    codeSignatureSection->writeHashes(buffer->getBufferStart());
1271
  }
1272
}
1273

1274
void Writer::writeOutputFile() {
1275
  TimeTraceScope timeScope("Write output file");
1276
  openFile();
1277
  reportPendingUndefinedSymbols();
1278
  if (errorCount())
1279
    return;
1280
  writeSections();
1281
  applyOptimizationHints();
1282
  buildFixupChains();
1283
  if (config->generateUuid)
1284
    writeUuid();
1285
  writeCodeSignature();
1286

1287
  if (auto e = buffer->commit())
1288
    fatal("failed to write output '" + buffer->getPath() +
1289
          "': " + toString(std::move(e)));
1290
}
1291

1292
template <class LP> void Writer::run() {
1293
  treatSpecialUndefineds();
1294
  if (config->entry && needsBinding(config->entry))
1295
    in.stubs->addEntry(config->entry);
1296

1297
  // Canonicalization of all pointers to InputSections should be handled by
1298
  // these two scan* methods. I.e. from this point onward, for all live
1299
  // InputSections, we should have `isec->canonical() == isec`.
1300
  scanSymbols();
1301
  if (in.objcStubs->isNeeded())
1302
    in.objcStubs->setUp();
1303
  if (in.objcMethList->isNeeded())
1304
    in.objcMethList->setUp();
1305
  scanRelocations();
1306
  if (in.initOffsets->isNeeded())
1307
    in.initOffsets->setUp();
1308

1309
  // Do not proceed if there were undefined or duplicate symbols.
1310
  reportPendingUndefinedSymbols();
1311
  reportPendingDuplicateSymbols();
1312
  if (errorCount())
1313
    return;
1314

1315
  if (in.stubHelper && in.stubHelper->isNeeded())
1316
    in.stubHelper->setUp();
1317

1318
  if (in.objCImageInfo->isNeeded())
1319
    in.objCImageInfo->finalizeContents();
1320

1321
  // At this point, we should know exactly which output sections are needed,
1322
  // courtesy of scanSymbols() and scanRelocations().
1323
  createOutputSections<LP>();
1324

1325
  // After this point, we create no new segments; HOWEVER, we might
1326
  // yet create branch-range extension thunks for architectures whose
1327
  // hardware call instructions have limited range, e.g., ARM(64).
1328
  // The thunks are created as InputSections interspersed among
1329
  // the ordinary __TEXT,_text InputSections.
1330
  sortSegmentsAndSections();
1331
  createLoadCommands<LP>();
1332
  finalizeAddresses();
1333
  threadPool.async([&] {
1334
    if (LLVM_ENABLE_THREADS && config->timeTraceEnabled)
1335
      timeTraceProfilerInitialize(config->timeTraceGranularity, "writeMapFile");
1336
    writeMapFile();
1337
    if (LLVM_ENABLE_THREADS && config->timeTraceEnabled)
1338
      timeTraceProfilerFinishThread();
1339
  });
1340
  finalizeLinkEditSegment();
1341
  writeOutputFile();
1342
}
1343

1344
template <class LP> void macho::writeResult() { Writer().run<LP>(); }
1345

1346
void macho::resetWriter() { LCDylib::resetInstanceCount(); }
1347

1348
void macho::createSyntheticSections() {
1349
  in.header = make<MachHeaderSection>();
1350
  if (config->dedupStrings)
1351
    in.cStringSection =
1352
        make<DeduplicatedCStringSection>(section_names::cString);
1353
  else
1354
    in.cStringSection = make<CStringSection>(section_names::cString);
1355
  in.objcMethnameSection =
1356
      make<DeduplicatedCStringSection>(section_names::objcMethname);
1357
  in.wordLiteralSection = make<WordLiteralSection>();
1358
  if (config->emitChainedFixups) {
1359
    in.chainedFixups = make<ChainedFixupsSection>();
1360
  } else {
1361
    in.rebase = make<RebaseSection>();
1362
    in.binding = make<BindingSection>();
1363
    in.weakBinding = make<WeakBindingSection>();
1364
    in.lazyBinding = make<LazyBindingSection>();
1365
    in.lazyPointers = make<LazyPointerSection>();
1366
    in.stubHelper = make<StubHelperSection>();
1367
  }
1368
  in.exports = make<ExportSection>();
1369
  in.got = make<GotSection>();
1370
  in.tlvPointers = make<TlvPointerSection>();
1371
  in.stubs = make<StubsSection>();
1372
  in.objcStubs = make<ObjCStubsSection>();
1373
  in.unwindInfo = makeUnwindInfoSection();
1374
  in.objCImageInfo = make<ObjCImageInfoSection>();
1375
  in.initOffsets = make<InitOffsetsSection>();
1376
  in.objcMethList = make<ObjCMethListSection>();
1377

1378
  // This section contains space for just a single word, and will be used by
1379
  // dyld to cache an address to the image loader it uses.
1380
  uint8_t *arr = bAlloc().Allocate<uint8_t>(target->wordSize);
1381
  memset(arr, 0, target->wordSize);
1382
  in.imageLoaderCache = makeSyntheticInputSection(
1383
      segment_names::data, section_names::data, S_REGULAR,
1384
      ArrayRef<uint8_t>{arr, target->wordSize},
1385
      /*align=*/target->wordSize);
1386
  assert(in.imageLoaderCache->live);
1387
}
1388

1389
OutputSection *macho::firstTLVDataSection = nullptr;
1390

1391
template void macho::writeResult<LP64>();
1392
template void macho::writeResult<ILP32>();
1393