1//===- SyntheticSections.h -------------------------------------*- C++ -*-===//
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#ifndef LLD_MACHO_SYNTHETIC_SECTIONS_H
10#define LLD_MACHO_SYNTHETIC_SECTIONS_H
11
12#include "Config.h"
13#include "ExportTrie.h"
14#include "InputSection.h"
15#include "OutputSection.h"
16#include "OutputSegment.h"
17#include "Target.h"
18#include "Writer.h"
19
20#include "llvm/ADT/DenseMap.h"
21#include "llvm/ADT/Hashing.h"
22#include "llvm/ADT/MapVector.h"
23#include "llvm/ADT/SetVector.h"
24#include "llvm/BinaryFormat/MachO.h"
25#include "llvm/Support/MathExtras.h"
26#include "llvm/Support/raw_ostream.h"
27
28#include <unordered_map>
29
30namespace llvm {
31class DWARFUnit;
32} // namespace llvm
33
34namespace lld::macho {
35
36class Defined;
37class DylibSymbol;
38class LoadCommand;
39class ObjFile;
40class UnwindInfoSection;
41
42class SyntheticSection : public OutputSection {
43public:
44 SyntheticSection(const char *segname, const char *name);
45 virtual ~SyntheticSection() = default;
46
47 static bool classof(const OutputSection *sec) {
48 return sec->kind() == SyntheticKind;
49 }
50
51 StringRef segname;
52 // This fake InputSection makes it easier for us to write code that applies
53 // generically to both user inputs and synthetics.
54 InputSection *isec;
55};
56
57// All sections in __LINKEDIT should inherit from this.
58class LinkEditSection : public SyntheticSection {
59public:
60 LinkEditSection(const char *segname, const char *name)
61 : SyntheticSection(segname, name) {
62 align = target->wordSize;
63 }
64
65 // Implementations of this method can assume that the regular (non-__LINKEDIT)
66 // sections already have their addresses assigned.
67 virtual void finalizeContents() {}
68
69 // Sections in __LINKEDIT are special: their offsets are recorded in the
70 // load commands like LC_DYLD_INFO_ONLY and LC_SYMTAB, instead of in section
71 // headers.
72 bool isHidden() const final { return true; }
73
74 virtual uint64_t getRawSize() const = 0;
75
76 // codesign (or more specifically libstuff) checks that each section in
77 // __LINKEDIT ends where the next one starts -- no gaps are permitted. We
78 // therefore align every section's start and end points to WordSize.
79 //
80 // NOTE: This assumes that the extra bytes required for alignment can be
81 // zero-valued bytes.
82 uint64_t getSize() const final { return llvm::alignTo(Value: getRawSize(), Align: align); }
83};
84
85// The header of the Mach-O file, which must have a file offset of zero.
86class MachHeaderSection final : public SyntheticSection {
87public:
88 MachHeaderSection();
89 bool isHidden() const override { return true; }
90 uint64_t getSize() const override;
91 void writeTo(uint8_t *buf) const override;
92
93 void addLoadCommand(LoadCommand *);
94
95protected:
96 std::vector<LoadCommand *> loadCommands;
97 uint32_t sizeOfCmds = 0;
98};
99
100// A hidden section that exists solely for the purpose of creating the
101// __PAGEZERO segment, which is used to catch null pointer dereferences.
102class PageZeroSection final : public SyntheticSection {
103public:
104 PageZeroSection();
105 bool isHidden() const override { return true; }
106 bool isNeeded() const override { return target->pageZeroSize != 0; }
107 uint64_t getSize() const override { return target->pageZeroSize; }
108 uint64_t getFileSize() const override { return 0; }
109 void writeTo(uint8_t *buf) const override {}
110};
111
112// This is the base class for the GOT and TLVPointer sections, which are nearly
113// functionally identical -- they will both be populated by dyld with addresses
114// to non-lazily-loaded dylib symbols. The main difference is that the
115// TLVPointerSection stores references to thread-local variables.
116class NonLazyPointerSectionBase : public SyntheticSection {
117public:
118 NonLazyPointerSectionBase(const char *segname, const char *name);
119 const llvm::SetVector<const Symbol *> &getEntries() const { return entries; }
120 bool isNeeded() const override { return !entries.empty(); }
121 uint64_t getSize() const override {
122 return entries.size() * target->wordSize;
123 }
124 void writeTo(uint8_t *buf) const override;
125 void addEntry(Symbol *sym);
126 uint64_t getVA(uint32_t gotIndex) const {
127 return addr + gotIndex * target->wordSize;
128 }
129
130private:
131 llvm::SetVector<const Symbol *> entries;
132};
133
134class GotSection final : public NonLazyPointerSectionBase {
135public:
136 GotSection();
137};
138
139class TlvPointerSection final : public NonLazyPointerSectionBase {
140public:
141 TlvPointerSection();
142};
143
144struct Location {
145 const InputSection *isec;
146 uint64_t offset;
147
148 Location(const InputSection *isec, uint64_t offset)
149 : isec(isec), offset(offset) {}
150 uint64_t getVA() const { return isec->getVA(off: offset); }
151};
152
153// Stores rebase opcodes, which tell dyld where absolute addresses have been
154// encoded in the binary. If the binary is not loaded at its preferred address,
155// dyld has to rebase these addresses by adding an offset to them.
156class RebaseSection final : public LinkEditSection {
157public:
158 RebaseSection();
159 void finalizeContents() override;
160 uint64_t getRawSize() const override { return contents.size(); }
161 bool isNeeded() const override { return !locations.empty(); }
162 void writeTo(uint8_t *buf) const override;
163
164 void addEntry(const InputSection *isec, uint64_t offset) {
165 if (config->isPic)
166 locations.emplace_back(args&: isec, args&: offset);
167 }
168
169private:
170 std::vector<Location> locations;
171 SmallVector<char, 128> contents;
172};
173
174struct BindingEntry {
175 int64_t addend;
176 Location target;
177 BindingEntry(int64_t addend, Location target)
178 : addend(addend), target(target) {}
179};
180
181template <class Sym>
182using BindingsMap = llvm::DenseMap<Sym, std::vector<BindingEntry>>;
183
184// Stores bind opcodes for telling dyld which symbols to load non-lazily.
185class BindingSection final : public LinkEditSection {
186public:
187 BindingSection();
188 void finalizeContents() override;
189 uint64_t getRawSize() const override { return contents.size(); }
190 bool isNeeded() const override { return !bindingsMap.empty(); }
191 void writeTo(uint8_t *buf) const override;
192
193 void addEntry(const Symbol *dysym, const InputSection *isec, uint64_t offset,
194 int64_t addend = 0) {
195 bindingsMap[dysym].emplace_back(args&: addend, args: Location(isec, offset));
196 }
197
198private:
199 BindingsMap<const Symbol *> bindingsMap;
200 SmallVector<char, 128> contents;
201};
202
203// Stores bind opcodes for telling dyld which weak symbols need coalescing.
204// There are two types of entries in this section:
205//
206// 1) Non-weak definitions: This is a symbol definition that weak symbols in
207// other dylibs should coalesce to.
208//
209// 2) Weak bindings: These tell dyld that a given symbol reference should
210// coalesce to a non-weak definition if one is found. Note that unlike the
211// entries in the BindingSection, the bindings here only refer to these
212// symbols by name, but do not specify which dylib to load them from.
213class WeakBindingSection final : public LinkEditSection {
214public:
215 WeakBindingSection();
216 void finalizeContents() override;
217 uint64_t getRawSize() const override { return contents.size(); }
218 bool isNeeded() const override {
219 return !bindingsMap.empty() || !definitions.empty();
220 }
221
222 void writeTo(uint8_t *buf) const override;
223
224 void addEntry(const Symbol *symbol, const InputSection *isec, uint64_t offset,
225 int64_t addend = 0) {
226 bindingsMap[symbol].emplace_back(args&: addend, args: Location(isec, offset));
227 }
228
229 bool hasEntry() const { return !bindingsMap.empty(); }
230
231 void addNonWeakDefinition(const Defined *defined) {
232 definitions.emplace_back(args&: defined);
233 }
234
235 bool hasNonWeakDefinition() const { return !definitions.empty(); }
236
237private:
238 BindingsMap<const Symbol *> bindingsMap;
239 std::vector<const Defined *> definitions;
240 SmallVector<char, 128> contents;
241};
242
243// The following sections implement lazy symbol binding -- very similar to the
244// PLT mechanism in ELF.
245//
246// ELF's .plt section is broken up into two sections in Mach-O: StubsSection
247// and StubHelperSection. Calls to functions in dylibs will end up calling into
248// StubsSection, which contains indirect jumps to addresses stored in the
249// LazyPointerSection (the counterpart to ELF's .plt.got).
250//
251// We will first describe how non-weak symbols are handled.
252//
253// At program start, the LazyPointerSection contains addresses that point into
254// one of the entry points in the middle of the StubHelperSection. The code in
255// StubHelperSection will push on the stack an offset into the
256// LazyBindingSection. The push is followed by a jump to the beginning of the
257// StubHelperSection (similar to PLT0), which then calls into dyld_stub_binder.
258// dyld_stub_binder is a non-lazily-bound symbol, so this call looks it up in
259// the GOT.
260//
261// The stub binder will look up the bind opcodes in the LazyBindingSection at
262// the given offset. The bind opcodes will tell the binder to update the
263// address in the LazyPointerSection to point to the symbol, so that subsequent
264// calls don't have to redo the symbol resolution. The binder will then jump to
265// the resolved symbol.
266//
267// With weak symbols, the situation is slightly different. Since there is no
268// "weak lazy" lookup, function calls to weak symbols are always non-lazily
269// bound. We emit both regular non-lazy bindings as well as weak bindings, in
270// order that the weak bindings may overwrite the non-lazy bindings if an
271// appropriate symbol is found at runtime. However, the bound addresses will
272// still be written (non-lazily) into the LazyPointerSection.
273//
274// Symbols are always bound eagerly when chained fixups are used. In that case,
275// StubsSection contains indirect jumps to addresses stored in the GotSection.
276// The GOT directly contains the fixup entries, which will be replaced by the
277// address of the target symbols on load. LazyPointerSection and
278// StubHelperSection are not used.
279
280class StubsSection final : public SyntheticSection {
281public:
282 StubsSection();
283 uint64_t getSize() const override;
284 bool isNeeded() const override { return !entries.empty(); }
285 void finalize() override;
286 void writeTo(uint8_t *buf) const override;
287 const llvm::SetVector<Symbol *> &getEntries() const { return entries; }
288 // Creates a stub for the symbol and the corresponding entry in the
289 // LazyPointerSection.
290 void addEntry(Symbol *);
291 uint64_t getVA(uint32_t stubsIndex) const {
292 assert(isFinal || target->usesThunks());
293 // ConcatOutputSection::finalize() can seek the address of a
294 // stub before its address is assigned. Before __stubs is
295 // finalized, return a contrived out-of-range address.
296 return isFinal ? addr + stubsIndex * target->stubSize
297 : TargetInfo::outOfRangeVA;
298 }
299
300 bool isFinal = false; // is address assigned?
301
302private:
303 llvm::SetVector<Symbol *> entries;
304};
305
306class StubHelperSection final : public SyntheticSection {
307public:
308 StubHelperSection();
309 uint64_t getSize() const override;
310 bool isNeeded() const override;
311 void writeTo(uint8_t *buf) const override;
312
313 void setUp();
314
315 DylibSymbol *stubBinder = nullptr;
316 Defined *dyldPrivate = nullptr;
317};
318
319class ObjCSelRefsHelper {
320public:
321 static void initialize();
322 static void cleanup();
323
324 static ConcatInputSection *getSelRef(StringRef methname);
325 static ConcatInputSection *makeSelRef(StringRef methname);
326
327private:
328 static llvm::DenseMap<llvm::CachedHashStringRef, ConcatInputSection *>
329 methnameToSelref;
330};
331
332// Objective-C stubs are hoisted objc_msgSend calls per selector called in the
333// program. Apple Clang produces undefined symbols to each stub, such as
334// '_objc_msgSend$foo', which are then synthesized by the linker. The stubs
335// load the particular selector 'foo' from __objc_selrefs, setting it to the
336// first argument of the objc_msgSend call, and then jumps to objc_msgSend. The
337// actual stub contents are mirrored from ld64.
338class ObjCStubsSection final : public SyntheticSection {
339public:
340 ObjCStubsSection();
341 void addEntry(Symbol *sym);
342 uint64_t getSize() const override;
343 bool isNeeded() const override { return !symbols.empty(); }
344 void finalize() override { isec->isFinal = true; }
345 void writeTo(uint8_t *buf) const override;
346 void setUp();
347
348 static constexpr llvm::StringLiteral symbolPrefix = "_objc_msgSend$";
349 static bool isObjCStubSymbol(Symbol *sym);
350 static StringRef getMethname(Symbol *sym);
351
352private:
353 std::vector<Defined *> symbols;
354 Symbol *objcMsgSend = nullptr;
355};
356
357// Note that this section may also be targeted by non-lazy bindings. In
358// particular, this happens when branch relocations target weak symbols.
359class LazyPointerSection final : public SyntheticSection {
360public:
361 LazyPointerSection();
362 uint64_t getSize() const override;
363 bool isNeeded() const override;
364 void writeTo(uint8_t *buf) const override;
365 uint64_t getVA(uint32_t index) const {
366 return addr + (index << target->p2WordSize);
367 }
368};
369
370class LazyBindingSection final : public LinkEditSection {
371public:
372 LazyBindingSection();
373 void finalizeContents() override;
374 uint64_t getRawSize() const override { return contents.size(); }
375 bool isNeeded() const override { return !entries.empty(); }
376 void writeTo(uint8_t *buf) const override;
377 // Note that every entry here will by referenced by a corresponding entry in
378 // the StubHelperSection.
379 void addEntry(Symbol *dysym);
380 const llvm::SetVector<Symbol *> &getEntries() const { return entries; }
381
382private:
383 uint32_t encode(const Symbol &);
384
385 llvm::SetVector<Symbol *> entries;
386 SmallVector<char, 128> contents;
387 llvm::raw_svector_ostream os{contents};
388};
389
390// Stores a trie that describes the set of exported symbols.
391class ExportSection final : public LinkEditSection {
392public:
393 ExportSection();
394 void finalizeContents() override;
395 uint64_t getRawSize() const override { return size; }
396 bool isNeeded() const override { return size; }
397 void writeTo(uint8_t *buf) const override;
398
399 bool hasWeakSymbol = false;
400
401private:
402 TrieBuilder trieBuilder;
403 size_t size = 0;
404};
405
406// Stores 'data in code' entries that describe the locations of data regions
407// inside code sections. This is used by llvm-objdump to distinguish jump tables
408// and stop them from being disassembled as instructions.
409class DataInCodeSection final : public LinkEditSection {
410public:
411 DataInCodeSection();
412 void finalizeContents() override;
413 uint64_t getRawSize() const override {
414 return sizeof(llvm::MachO::data_in_code_entry) * entries.size();
415 }
416 void writeTo(uint8_t *buf) const override;
417
418private:
419 std::vector<llvm::MachO::data_in_code_entry> entries;
420};
421
422// Stores ULEB128 delta encoded addresses of functions.
423class FunctionStartsSection final : public LinkEditSection {
424public:
425 FunctionStartsSection();
426 void finalizeContents() override;
427 uint64_t getRawSize() const override { return contents.size(); }
428 void writeTo(uint8_t *buf) const override;
429
430private:
431 SmallVector<char, 128> contents;
432};
433
434// Stores the strings referenced by the symbol table.
435class StringTableSection final : public LinkEditSection {
436public:
437 StringTableSection();
438 // Returns the start offset of the added string.
439 uint32_t addString(StringRef);
440 uint64_t getRawSize() const override { return size; }
441 void writeTo(uint8_t *buf) const override;
442
443 static constexpr size_t emptyStringIndex = 1;
444
445private:
446 // ld64 emits string tables which start with a space and a zero byte. We
447 // match its behavior here since some tools depend on it.
448 // Consequently, the empty string will be at index 1, not zero.
449 std::vector<StringRef> strings{" "};
450 llvm::DenseMap<llvm::CachedHashStringRef, uint32_t> stringMap;
451 size_t size = 2;
452};
453
454struct SymtabEntry {
455 Symbol *sym;
456 size_t strx;
457};
458
459struct StabsEntry {
460 uint8_t type = 0;
461 uint32_t strx = StringTableSection::emptyStringIndex;
462 uint8_t sect = 0;
463 uint16_t desc = 0;
464 uint64_t value = 0;
465
466 StabsEntry() = default;
467 explicit StabsEntry(uint8_t type) : type(type) {}
468};
469
470// Symbols of the same type must be laid out contiguously: we choose to emit
471// all local symbols first, then external symbols, and finally undefined
472// symbols. For each symbol type, the LC_DYSYMTAB load command will record the
473// range (start index and total number) of those symbols in the symbol table.
474class SymtabSection : public LinkEditSection {
475public:
476 void finalizeContents() override;
477 uint32_t getNumSymbols() const;
478 uint32_t getNumLocalSymbols() const {
479 return stabs.size() + localSymbols.size();
480 }
481 uint32_t getNumExternalSymbols() const { return externalSymbols.size(); }
482 uint32_t getNumUndefinedSymbols() const { return undefinedSymbols.size(); }
483
484private:
485 void emitBeginSourceStab(StringRef);
486 void emitEndSourceStab();
487 void emitObjectFileStab(ObjFile *);
488 void emitEndFunStab(Defined *);
489 Defined *getFuncBodySym(Defined *);
490 void emitStabs();
491
492protected:
493 SymtabSection(StringTableSection &);
494
495 StringTableSection &stringTableSection;
496 // STABS symbols are always local symbols, but we represent them with special
497 // entries because they may use fields like n_sect and n_desc differently.
498 std::vector<StabsEntry> stabs;
499 std::vector<SymtabEntry> localSymbols;
500 std::vector<SymtabEntry> externalSymbols;
501 std::vector<SymtabEntry> undefinedSymbols;
502};
503
504template <class LP> SymtabSection *makeSymtabSection(StringTableSection &);
505
506// The indirect symbol table is a list of 32-bit integers that serve as indices
507// into the (actual) symbol table. The indirect symbol table is a
508// concatenation of several sub-arrays of indices, each sub-array belonging to
509// a separate section. The starting offset of each sub-array is stored in the
510// reserved1 header field of the respective section.
511//
512// These sub-arrays provide symbol information for sections that store
513// contiguous sequences of symbol references. These references can be pointers
514// (e.g. those in the GOT and TLVP sections) or assembly sequences (e.g.
515// function stubs).
516class IndirectSymtabSection final : public LinkEditSection {
517public:
518 IndirectSymtabSection();
519 void finalizeContents() override;
520 uint32_t getNumSymbols() const;
521 uint64_t getRawSize() const override {
522 return getNumSymbols() * sizeof(uint32_t);
523 }
524 bool isNeeded() const override;
525 void writeTo(uint8_t *buf) const override;
526};
527
528// The code signature comes at the very end of the linked output file.
529class CodeSignatureSection final : public LinkEditSection {
530public:
531 // NOTE: These values are duplicated in llvm-objcopy's MachO/Object.h file
532 // and any changes here, should be repeated there.
533 static constexpr uint8_t blockSizeShift = 12;
534 static constexpr size_t blockSize = (1 << blockSizeShift); // 4 KiB
535 static constexpr size_t hashSize = 256 / 8;
536 static constexpr size_t blobHeadersSize = llvm::alignTo<8>(
537 Value: sizeof(llvm::MachO::CS_SuperBlob) + sizeof(llvm::MachO::CS_BlobIndex));
538 static constexpr uint32_t fixedHeadersSize =
539 blobHeadersSize + sizeof(llvm::MachO::CS_CodeDirectory);
540
541 uint32_t fileNamePad = 0;
542 uint32_t allHeadersSize = 0;
543 StringRef fileName;
544
545 CodeSignatureSection();
546 uint64_t getRawSize() const override;
547 bool isNeeded() const override { return true; }
548 void writeTo(uint8_t *buf) const override;
549 uint32_t getBlockCount() const;
550 void writeHashes(uint8_t *buf) const;
551};
552
553class CStringSection : public SyntheticSection {
554public:
555 CStringSection(const char *name);
556 void addInput(CStringInputSection *);
557 uint64_t getSize() const override { return size; }
558 virtual void finalizeContents();
559 bool isNeeded() const override { return !inputs.empty(); }
560 void writeTo(uint8_t *buf) const override;
561
562 std::vector<CStringInputSection *> inputs;
563
564private:
565 uint64_t size;
566};
567
568class DeduplicatedCStringSection final : public CStringSection {
569public:
570 DeduplicatedCStringSection(const char *name) : CStringSection(name){};
571 uint64_t getSize() const override { return size; }
572 void finalizeContents() override;
573 void writeTo(uint8_t *buf) const override;
574 uint64_t getStringOffset(StringRef str) const;
575
576private:
577 llvm::DenseMap<llvm::CachedHashStringRef, uint64_t> stringOffsetMap;
578 size_t size = 0;
579};
580
581/*
582 * This section contains deduplicated literal values. The 16-byte values are
583 * laid out first, followed by the 8- and then the 4-byte ones.
584 */
585class WordLiteralSection final : public SyntheticSection {
586public:
587 using UInt128 = std::pair<uint64_t, uint64_t>;
588 // I don't think the standard guarantees the size of a pair, so let's make
589 // sure it's exact -- that way we can construct it via `mmap`.
590 static_assert(sizeof(UInt128) == 16);
591
592 WordLiteralSection();
593 void addInput(WordLiteralInputSection *);
594 void finalizeContents();
595 void writeTo(uint8_t *buf) const override;
596
597 uint64_t getSize() const override {
598 return literal16Map.size() * 16 + literal8Map.size() * 8 +
599 literal4Map.size() * 4;
600 }
601
602 bool isNeeded() const override {
603 return !literal16Map.empty() || !literal4Map.empty() ||
604 !literal8Map.empty();
605 }
606
607 uint64_t getLiteral16Offset(uintptr_t buf) const {
608 return literal16Map.at(k: *reinterpret_cast<const UInt128 *>(buf)) * 16;
609 }
610
611 uint64_t getLiteral8Offset(uintptr_t buf) const {
612 return literal16Map.size() * 16 +
613 literal8Map.at(k: *reinterpret_cast<const uint64_t *>(buf)) * 8;
614 }
615
616 uint64_t getLiteral4Offset(uintptr_t buf) const {
617 return literal16Map.size() * 16 + literal8Map.size() * 8 +
618 literal4Map.at(k: *reinterpret_cast<const uint32_t *>(buf)) * 4;
619 }
620
621private:
622 std::vector<WordLiteralInputSection *> inputs;
623
624 template <class T> struct Hasher {
625 llvm::hash_code operator()(T v) const { return llvm::hash_value(v); }
626 };
627 // We're using unordered_map instead of DenseMap here because we need to
628 // support all possible integer values -- there are no suitable tombstone
629 // values for DenseMap.
630 std::unordered_map<UInt128, uint64_t, Hasher<UInt128>> literal16Map;
631 std::unordered_map<uint64_t, uint64_t> literal8Map;
632 std::unordered_map<uint32_t, uint64_t> literal4Map;
633};
634
635class ObjCImageInfoSection final : public SyntheticSection {
636public:
637 ObjCImageInfoSection();
638 bool isNeeded() const override { return !files.empty(); }
639 uint64_t getSize() const override { return 8; }
640 void addFile(const InputFile *file) {
641 assert(!file->objCImageInfo.empty());
642 files.push_back(x: file);
643 }
644 void finalizeContents();
645 void writeTo(uint8_t *buf) const override;
646
647private:
648 struct ImageInfo {
649 uint8_t swiftVersion = 0;
650 bool hasCategoryClassProperties = false;
651 } info;
652 static ImageInfo parseImageInfo(const InputFile *);
653 std::vector<const InputFile *> files; // files with image info
654};
655
656// This section stores 32-bit __TEXT segment offsets of initializer functions.
657//
658// The compiler stores pointers to initializers in __mod_init_func. These need
659// to be fixed up at load time, which takes time and dirties memory. By
660// synthesizing InitOffsetsSection from them, this data can live in the
661// read-only __TEXT segment instead. This section is used by default when
662// chained fixups are enabled.
663//
664// There is no similar counterpart to __mod_term_func, as that section is
665// deprecated, and static destructors are instead handled by registering them
666// via __cxa_atexit from an autogenerated initializer function (see D121736).
667class InitOffsetsSection final : public SyntheticSection {
668public:
669 InitOffsetsSection();
670 bool isNeeded() const override { return !sections.empty(); }
671 uint64_t getSize() const override;
672 void writeTo(uint8_t *buf) const override;
673 void setUp();
674
675 void addInput(ConcatInputSection *isec) { sections.push_back(x: isec); }
676 const std::vector<ConcatInputSection *> &inputs() const { return sections; }
677
678private:
679 std::vector<ConcatInputSection *> sections;
680};
681
682// This SyntheticSection is for the __objc_methlist section, which contains
683// relative method lists if the -objc_relative_method_lists option is enabled.
684class ObjCMethListSection final : public SyntheticSection {
685public:
686 ObjCMethListSection();
687
688 static bool isMethodList(const ConcatInputSection *isec);
689 void addInput(ConcatInputSection *isec) { inputs.push_back(x: isec); }
690 std::vector<ConcatInputSection *> getInputs() { return inputs; }
691
692 void setUp();
693 void finalize() override;
694 bool isNeeded() const override { return !inputs.empty(); }
695 uint64_t getSize() const override { return sectionSize; }
696 void writeTo(uint8_t *bufStart) const override;
697
698private:
699 void readMethodListHeader(const uint8_t *buf, uint32_t &structSizeAndFlags,
700 uint32_t &structCount) const;
701 void writeMethodListHeader(uint8_t *buf, uint32_t structSizeAndFlags,
702 uint32_t structCount) const;
703 uint32_t computeRelativeMethodListSize(uint32_t absoluteMethodListSize) const;
704 void writeRelativeOffsetForIsec(const ConcatInputSection *isec, uint8_t *buf,
705 uint32_t &inSecOff, uint32_t &outSecOff,
706 bool useSelRef) const;
707 uint32_t writeRelativeMethodList(const ConcatInputSection *isec,
708 uint8_t *buf) const;
709
710 static constexpr uint32_t methodListHeaderSize =
711 /*structSizeAndFlags*/ sizeof(uint32_t) +
712 /*structCount*/ sizeof(uint32_t);
713 // Relative method lists are supported only for 3-pointer method lists
714 static constexpr uint32_t pointersPerStruct = 3;
715 // The runtime identifies relative method lists via this magic value
716 static constexpr uint32_t relMethodHeaderFlag = 0x80000000;
717 // In the method list header, the first 2 bytes are the size of struct
718 static constexpr uint32_t structSizeMask = 0x0000FFFF;
719 // In the method list header, the last 2 bytes are the flags for the struct
720 static constexpr uint32_t structFlagsMask = 0xFFFF0000;
721 // Relative method lists have 4 byte alignment as all data in the InputSection
722 // is 4 byte
723 static constexpr uint32_t relativeOffsetSize = sizeof(uint32_t);
724
725 // The output size of the __objc_methlist section, computed during finalize()
726 uint32_t sectionSize = 0;
727 std::vector<ConcatInputSection *> inputs;
728};
729
730// Chained fixups are a replacement for classic dyld opcodes. In this format,
731// most of the metadata necessary for binding symbols and rebasing addresses is
732// stored directly in the memory location that will have the fixup applied.
733//
734// The fixups form singly linked lists; each one covering a single page in
735// memory. The __LINKEDIT,__chainfixups section stores the page offset of the
736// first fixup of each page; the rest can be found by walking the chain using
737// the offset that is embedded in each entry.
738//
739// This setup allows pages to be relocated lazily at page-in time and without
740// being dirtied. The kernel can discard and load them again as needed. This
741// technique, called page-in linking, was introduced in macOS 13.
742//
743// The benefits of this format are:
744// - smaller __LINKEDIT segment, as most of the fixup information is stored in
745// the data segment
746// - faster startup, since not all relocations need to be done upfront
747// - slightly lower memory usage, as fewer pages are dirtied
748//
749// Userspace x86_64 and arm64 binaries have two types of fixup entries:
750// - Rebase entries contain an absolute address, to which the object's load
751// address will be added to get the final value. This is used for loading
752// the address of a symbol defined in the same binary.
753// - Binding entries are mostly used for symbols imported from other dylibs,
754// but for weakly bound and interposable symbols as well. They are looked up
755// by a (symbol name, library) pair stored in __chainfixups. This import
756// entry also encodes whether the import is weak (i.e. if the symbol is
757// missing, it should be set to null instead of producing a load error).
758// The fixup encodes an ordinal associated with the import, and an optional
759// addend.
760//
761// The entries are tightly packed 64-bit bitfields. One of the bits specifies
762// which kind of fixup to interpret them as.
763//
764// LLD generates the fixup data in 5 stages:
765// 1. While scanning relocations, we make a note of each location that needs
766// a fixup by calling addRebase() or addBinding(). During this, we assign
767// a unique ordinal for each (symbol name, library, addend) import tuple.
768// 2. After addresses have been assigned to all sections, and thus the memory
769// layout of the linked image is final; finalizeContents() is called. Here,
770// the page offsets of the chain start entries are calculated.
771// 3. ChainedFixupsSection::writeTo() writes the page start offsets and the
772// imports table to the output file.
773// 4. Each section's fixup entries are encoded and written to disk in
774// ConcatInputSection::writeTo(), but without writing the offsets that form
775// the chain.
776// 5. Finally, each page's (which might correspond to multiple sections)
777// fixups are linked together in Writer::buildFixupChains().
778class ChainedFixupsSection final : public LinkEditSection {
779public:
780 ChainedFixupsSection();
781 void finalizeContents() override;
782 uint64_t getRawSize() const override { return size; }
783 bool isNeeded() const override;
784 void writeTo(uint8_t *buf) const override;
785
786 void addRebase(const InputSection *isec, uint64_t offset) {
787 locations.emplace_back(args&: isec, args&: offset);
788 }
789 void addBinding(const Symbol *dysym, const InputSection *isec,
790 uint64_t offset, int64_t addend = 0);
791
792 void setHasNonWeakDefinition() { hasNonWeakDef = true; }
793
794 // Returns an (ordinal, inline addend) tuple used by dyld_chained_ptr_64_bind.
795 std::pair<uint32_t, uint8_t> getBinding(const Symbol *sym,
796 int64_t addend) const;
797
798 const std::vector<Location> &getLocations() const { return locations; }
799
800 bool hasWeakBinding() const { return hasWeakBind; }
801 bool hasNonWeakDefinition() const { return hasNonWeakDef; }
802
803private:
804 // Location::offset initially stores the offset within an InputSection, but
805 // contains output segment offsets after finalizeContents().
806 std::vector<Location> locations;
807 // (target symbol, addend) => import ordinal
808 llvm::MapVector<std::pair<const Symbol *, int64_t>, uint32_t> bindings;
809
810 struct SegmentInfo {
811 SegmentInfo(const OutputSegment *oseg) : oseg(oseg) {}
812
813 const OutputSegment *oseg;
814 // (page index, fixup starts offset)
815 llvm::SmallVector<std::pair<uint16_t, uint16_t>> pageStarts;
816
817 size_t getSize() const;
818 size_t writeTo(uint8_t *buf) const;
819 };
820 llvm::SmallVector<SegmentInfo, 4> fixupSegments;
821
822 size_t symtabSize = 0;
823 size_t size = 0;
824
825 bool needsAddend = false;
826 bool needsLargeAddend = false;
827 bool hasWeakBind = false;
828 bool hasNonWeakDef = false;
829 llvm::MachO::ChainedImportFormat importFormat;
830};
831
832void writeChainedRebase(uint8_t *buf, uint64_t targetVA);
833void writeChainedFixup(uint8_t *buf, const Symbol *sym, int64_t addend);
834
835struct InStruct {
836 const uint8_t *bufferStart = nullptr;
837 MachHeaderSection *header = nullptr;
838 /// The list of cstring sections. Note that this includes \p cStringSection
839 /// and \p objcMethnameSection already.
840 llvm::SmallVector<CStringSection *> cStringSections;
841 CStringSection *cStringSection = nullptr;
842 DeduplicatedCStringSection *objcMethnameSection = nullptr;
843 WordLiteralSection *wordLiteralSection = nullptr;
844 RebaseSection *rebase = nullptr;
845 BindingSection *binding = nullptr;
846 WeakBindingSection *weakBinding = nullptr;
847 LazyBindingSection *lazyBinding = nullptr;
848 ExportSection *exports = nullptr;
849 GotSection *got = nullptr;
850 TlvPointerSection *tlvPointers = nullptr;
851 LazyPointerSection *lazyPointers = nullptr;
852 StubsSection *stubs = nullptr;
853 StubHelperSection *stubHelper = nullptr;
854 ObjCStubsSection *objcStubs = nullptr;
855 UnwindInfoSection *unwindInfo = nullptr;
856 ObjCImageInfoSection *objCImageInfo = nullptr;
857 ConcatInputSection *imageLoaderCache = nullptr;
858 InitOffsetsSection *initOffsets = nullptr;
859 ObjCMethListSection *objcMethList = nullptr;
860 ChainedFixupsSection *chainedFixups = nullptr;
861
862 CStringSection *getOrCreateCStringSection(StringRef name,
863 bool forceDedupStrings = false) {
864 auto [it, didEmplace] =
865 cStringSectionMap.try_emplace(Key: name, Args: cStringSections.size());
866 if (!didEmplace)
867 return cStringSections[it->getValue()];
868
869 std::string &nameData = *make<std::string>(args&: name);
870 CStringSection *sec;
871 if (config->dedupStrings || forceDedupStrings)
872 sec = make<DeduplicatedCStringSection>(args: nameData.c_str());
873 else
874 sec = make<CStringSection>(args: nameData.c_str());
875 cStringSections.push_back(Elt: sec);
876 return sec;
877 }
878
879private:
880 llvm::StringMap<unsigned> cStringSectionMap;
881};
882
883extern InStruct in;
884extern std::vector<SyntheticSection *> syntheticSections;
885
886void createSyntheticSymbols();
887
888} // namespace lld::macho
889
890#endif
891