Bug Summary

File:build/source/lld/MachO/SyntheticSections.cpp
Warning:line 1887, column 42
1st function call argument is an uninitialized value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name SyntheticSections.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -resource-dir /usr/lib/llvm-17/lib/clang/17 -D LLD_VENDOR="Debian" -D _DEBUG -D _GLIBCXX_ASSERTIONS -D _GNU_SOURCE -D _LIBCPP_ENABLE_ASSERTIONS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I tools/lld/MachO -I /build/source/lld/MachO -I /build/source/lld/include -I tools/lld/include -I include -I /build/source/llvm/include -I /build/source/llvm/../libunwind/include -D _FORTIFY_SOURCE=2 -D NDEBUG -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/x86_64-linux-gnu/c++/10 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../include/c++/10/backward -internal-isystem /usr/lib/llvm-17/lib/clang/17/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/10/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fmacro-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fmacro-prefix-map=/build/source/= -fcoverage-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fcoverage-prefix-map=/build/source/= -source-date-epoch 1683717183 -O2 -Wno-unused-command-line-argument -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wno-comment -Wno-misleading-indentation -std=c++17 -fdeprecated-macro -fdebug-compilation-dir=/build/source/build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/build-llvm/tools/clang/stage2-bins=build-llvm/tools/clang/stage2-bins -fdebug-prefix-map=/build/source/= -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -fcolor-diagnostics -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2023-05-10-133810-16478-1 -x c++ /build/source/lld/MachO/SyntheticSections.cpp
1//===- SyntheticSections.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 "SyntheticSections.h"
10#include "ConcatOutputSection.h"
11#include "Config.h"
12#include "ExportTrie.h"
13#include "InputFiles.h"
14#include "MachOStructs.h"
15#include "OutputSegment.h"
16#include "SymbolTable.h"
17#include "Symbols.h"
18
19#include "lld/Common/CommonLinkerContext.h"
20#include "llvm/ADT/STLExtras.h"
21#include "llvm/Config/llvm-config.h"
22#include "llvm/Support/EndianStream.h"
23#include "llvm/Support/FileSystem.h"
24#include "llvm/Support/LEB128.h"
25#include "llvm/Support/Parallel.h"
26#include "llvm/Support/Path.h"
27#include "llvm/Support/xxhash.h"
28
29#if defined(__APPLE__)
30#include <sys/mman.h>
31
32#define COMMON_DIGEST_FOR_OPENSSL
33#include <CommonCrypto/CommonDigest.h>
34#else
35#include "llvm/Support/SHA256.h"
36#endif
37
38#ifdef LLVM_HAVE_LIBXAR
39#include <fcntl.h>
40extern "C" {
41#include <xar/xar.h>
42}
43#endif
44
45using namespace llvm;
46using namespace llvm::MachO;
47using namespace llvm::support;
48using namespace llvm::support::endian;
49using namespace lld;
50using namespace lld::macho;
51
52// Reads `len` bytes at data and writes the 32-byte SHA256 checksum to `output`.
53static void sha256(const uint8_t *data, size_t len, uint8_t *output) {
54#if defined(__APPLE__)
55 // FIXME: Make LLVM's SHA256 faster and use it unconditionally. See PR56121
56 // for some notes on this.
57 CC_SHA256(data, len, output);
58#else
59 ArrayRef<uint8_t> block(data, len);
60 std::array<uint8_t, 32> hash = SHA256::hash(block);
61 static_assert(hash.size() == CodeSignatureSection::hashSize);
62 memcpy(output, hash.data(), hash.size());
63#endif
64}
65
66InStruct macho::in;
67std::vector<SyntheticSection *> macho::syntheticSections;
68
69SyntheticSection::SyntheticSection(const char *segname, const char *name)
70 : OutputSection(SyntheticKind, name) {
71 std::tie(this->segname, this->name) = maybeRenameSection({segname, name});
72 isec = makeSyntheticInputSection(segname, name);
73 isec->parent = this;
74 syntheticSections.push_back(this);
75}
76
77// dyld3's MachOLoaded::getSlide() assumes that the __TEXT segment starts
78// from the beginning of the file (i.e. the header).
79MachHeaderSection::MachHeaderSection()
80 : SyntheticSection(segment_names::text, section_names::header) {
81 // XXX: This is a hack. (See D97007)
82 // Setting the index to 1 to pretend that this section is the text
83 // section.
84 index = 1;
85 isec->isFinal = true;
86}
87
88void MachHeaderSection::addLoadCommand(LoadCommand *lc) {
89 loadCommands.push_back(lc);
90 sizeOfCmds += lc->getSize();
91}
92
93uint64_t MachHeaderSection::getSize() const {
94 uint64_t size = target->headerSize + sizeOfCmds + config->headerPad;
95 // If we are emitting an encryptable binary, our load commands must have a
96 // separate (non-encrypted) page to themselves.
97 if (config->emitEncryptionInfo)
98 size = alignToPowerOf2(size, target->getPageSize());
99 return size;
100}
101
102static uint32_t cpuSubtype() {
103 uint32_t subtype = target->cpuSubtype;
104
105 if (config->outputType == MH_EXECUTE && !config->staticLink &&
106 target->cpuSubtype == CPU_SUBTYPE_X86_64_ALL &&
107 config->platform() == PLATFORM_MACOS &&
108 config->platformInfo.target.MinDeployment >= VersionTuple(10, 5))
109 subtype |= CPU_SUBTYPE_LIB64;
110
111 return subtype;
112}
113
114static bool hasWeakBinding() {
115 return config->emitChainedFixups ? in.chainedFixups->hasWeakBinding()
116 : in.weakBinding->hasEntry();
117}
118
119static bool hasNonWeakDefinition() {
120 return config->emitChainedFixups ? in.chainedFixups->hasNonWeakDefinition()
121 : in.weakBinding->hasNonWeakDefinition();
122}
123
124void MachHeaderSection::writeTo(uint8_t *buf) const {
125 auto *hdr = reinterpret_cast<mach_header *>(buf);
126 hdr->magic = target->magic;
127 hdr->cputype = target->cpuType;
128 hdr->cpusubtype = cpuSubtype();
129 hdr->filetype = config->outputType;
130 hdr->ncmds = loadCommands.size();
131 hdr->sizeofcmds = sizeOfCmds;
132 hdr->flags = MH_DYLDLINK;
133
134 if (config->namespaceKind == NamespaceKind::twolevel)
135 hdr->flags |= MH_NOUNDEFS | MH_TWOLEVEL;
136
137 if (config->outputType == MH_DYLIB && !config->hasReexports)
138 hdr->flags |= MH_NO_REEXPORTED_DYLIBS;
139
140 if (config->markDeadStrippableDylib)
141 hdr->flags |= MH_DEAD_STRIPPABLE_DYLIB;
142
143 if (config->outputType == MH_EXECUTE && config->isPic)
144 hdr->flags |= MH_PIE;
145
146 if (config->outputType == MH_DYLIB && config->applicationExtension)
147 hdr->flags |= MH_APP_EXTENSION_SAFE;
148
149 if (in.exports->hasWeakSymbol || hasNonWeakDefinition())
150 hdr->flags |= MH_WEAK_DEFINES;
151
152 if (in.exports->hasWeakSymbol || hasWeakBinding())
153 hdr->flags |= MH_BINDS_TO_WEAK;
154
155 for (const OutputSegment *seg : outputSegments) {
156 for (const OutputSection *osec : seg->getSections()) {
157 if (isThreadLocalVariables(osec->flags)) {
158 hdr->flags |= MH_HAS_TLV_DESCRIPTORS;
159 break;
160 }
161 }
162 }
163
164 uint8_t *p = reinterpret_cast<uint8_t *>(hdr) + target->headerSize;
165 for (const LoadCommand *lc : loadCommands) {
166 lc->writeTo(p);
167 p += lc->getSize();
168 }
169}
170
171PageZeroSection::PageZeroSection()
172 : SyntheticSection(segment_names::pageZero, section_names::pageZero) {}
173
174RebaseSection::RebaseSection()
175 : LinkEditSection(segment_names::linkEdit, section_names::rebase) {}
176
177namespace {
178struct RebaseState {
179 uint64_t sequenceLength;
180 uint64_t skipLength;
181};
182} // namespace
183
184static void emitIncrement(uint64_t incr, raw_svector_ostream &os) {
185 assert(incr != 0)(static_cast <bool> (incr != 0) ? void (0) : __assert_fail
("incr != 0", "lld/MachO/SyntheticSections.cpp", 185, __extension__
__PRETTY_FUNCTION__))
;
186
187 if ((incr >> target->p2WordSize) <= REBASE_IMMEDIATE_MASK &&
188 (incr % target->wordSize) == 0) {
189 os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_IMM_SCALED |
190 (incr >> target->p2WordSize));
191 } else {
192 os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_ULEB);
193 encodeULEB128(incr, os);
194 }
195}
196
197static void flushRebase(const RebaseState &state, raw_svector_ostream &os) {
198 assert(state.sequenceLength > 0)(static_cast <bool> (state.sequenceLength > 0) ? void
(0) : __assert_fail ("state.sequenceLength > 0", "lld/MachO/SyntheticSections.cpp"
, 198, __extension__ __PRETTY_FUNCTION__))
;
199
200 if (state.skipLength == target->wordSize) {
201 if (state.sequenceLength <= REBASE_IMMEDIATE_MASK) {
202 os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_IMM_TIMES |
203 state.sequenceLength);
204 } else {
205 os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
206 encodeULEB128(state.sequenceLength, os);
207 }
208 } else if (state.sequenceLength == 1) {
209 os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB);
210 encodeULEB128(state.skipLength - target->wordSize, os);
211 } else {
212 os << static_cast<uint8_t>(
213 REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB);
214 encodeULEB128(state.sequenceLength, os);
215 encodeULEB128(state.skipLength - target->wordSize, os);
216 }
217}
218
219// Rebases are communicated to dyld using a bytecode, whose opcodes cause the
220// memory location at a specific address to be rebased and/or the address to be
221// incremented.
222//
223// Opcode REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB is the most generic
224// one, encoding a series of evenly spaced addresses. This algorithm works by
225// splitting up the sorted list of addresses into such chunks. If the locations
226// are consecutive or the sequence consists of a single location, flushRebase
227// will use a smaller, more specialized encoding.
228static void encodeRebases(const OutputSegment *seg,
229 MutableArrayRef<Location> locations,
230 raw_svector_ostream &os) {
231 // dyld operates on segments. Translate section offsets into segment offsets.
232 for (Location &loc : locations)
233 loc.offset =
234 loc.isec->parent->getSegmentOffset() + loc.isec->getOffset(loc.offset);
235 // The algorithm assumes that locations are unique.
236 Location *end =
237 llvm::unique(locations, [](const Location &a, const Location &b) {
238 return a.offset == b.offset;
239 });
240 size_t count = end - locations.begin();
241
242 os << static_cast<uint8_t>(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
243 seg->index);
244 assert(!locations.empty())(static_cast <bool> (!locations.empty()) ? void (0) : __assert_fail
("!locations.empty()", "lld/MachO/SyntheticSections.cpp", 244
, __extension__ __PRETTY_FUNCTION__))
;
245 uint64_t offset = locations[0].offset;
246 encodeULEB128(offset, os);
247
248 RebaseState state{1, target->wordSize};
249
250 for (size_t i = 1; i < count; ++i) {
251 offset = locations[i].offset;
252
253 uint64_t skip = offset - locations[i - 1].offset;
254 assert(skip != 0 && "duplicate locations should have been weeded out")(static_cast <bool> (skip != 0 && "duplicate locations should have been weeded out"
) ? void (0) : __assert_fail ("skip != 0 && \"duplicate locations should have been weeded out\""
, "lld/MachO/SyntheticSections.cpp", 254, __extension__ __PRETTY_FUNCTION__
))
;
255
256 if (skip == state.skipLength) {
257 ++state.sequenceLength;
258 } else if (state.sequenceLength == 1) {
259 ++state.sequenceLength;
260 state.skipLength = skip;
261 } else if (skip < state.skipLength) {
262 // The address is lower than what the rebase pointer would be if the last
263 // location would be part of a sequence. We start a new sequence from the
264 // previous location.
265 --state.sequenceLength;
266 flushRebase(state, os);
267
268 state.sequenceLength = 2;
269 state.skipLength = skip;
270 } else {
271 // The address is at some positive offset from the rebase pointer. We
272 // start a new sequence which begins with the current location.
273 flushRebase(state, os);
274 emitIncrement(skip - state.skipLength, os);
275 state.sequenceLength = 1;
276 state.skipLength = target->wordSize;
277 }
278 }
279 flushRebase(state, os);
280}
281
282void RebaseSection::finalizeContents() {
283 if (locations.empty())
284 return;
285
286 raw_svector_ostream os{contents};
287 os << static_cast<uint8_t>(REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);
288
289 llvm::sort(locations, [](const Location &a, const Location &b) {
290 return a.isec->getVA(a.offset) < b.isec->getVA(b.offset);
291 });
292
293 for (size_t i = 0, count = locations.size(); i < count;) {
294 const OutputSegment *seg = locations[i].isec->parent->parent;
295 size_t j = i + 1;
296 while (j < count && locations[j].isec->parent->parent == seg)
297 ++j;
298 encodeRebases(seg, {locations.data() + i, locations.data() + j}, os);
299 i = j;
300 }
301 os << static_cast<uint8_t>(REBASE_OPCODE_DONE);
302}
303
304void RebaseSection::writeTo(uint8_t *buf) const {
305 memcpy(buf, contents.data(), contents.size());
306}
307
308NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
309 const char *name)
310 : SyntheticSection(segname, name) {
311 align = target->wordSize;
312}
313
314void macho::addNonLazyBindingEntries(const Symbol *sym,
315 const InputSection *isec, uint64_t offset,
316 int64_t addend) {
317 if (config->emitChainedFixups) {
318 if (needsBinding(sym))
319 in.chainedFixups->addBinding(sym, isec, offset, addend);
320 else if (isa<Defined>(sym))
321 in.chainedFixups->addRebase(isec, offset);
322 else
323 llvm_unreachable("cannot bind to an undefined symbol")::llvm::llvm_unreachable_internal("cannot bind to an undefined symbol"
, "lld/MachO/SyntheticSections.cpp", 323)
;
324 return;
325 }
326
327 if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
328 in.binding->addEntry(dysym, isec, offset, addend);
329 if (dysym->isWeakDef())
330 in.weakBinding->addEntry(sym, isec, offset, addend);
331 } else if (const auto *defined = dyn_cast<Defined>(sym)) {
332 in.rebase->addEntry(isec, offset);
333 if (defined->isExternalWeakDef())
334 in.weakBinding->addEntry(sym, isec, offset, addend);
335 else if (defined->interposable)
336 in.binding->addEntry(sym, isec, offset, addend);
337 } else {
338 // Undefined symbols are filtered out in scanRelocations(); we should never
339 // get here
340 llvm_unreachable("cannot bind to an undefined symbol")::llvm::llvm_unreachable_internal("cannot bind to an undefined symbol"
, "lld/MachO/SyntheticSections.cpp", 340)
;
341 }
342}
343
344void NonLazyPointerSectionBase::addEntry(Symbol *sym) {
345 if (entries.insert(sym)) {
346 assert(!sym->isInGot())(static_cast <bool> (!sym->isInGot()) ? void (0) : __assert_fail
("!sym->isInGot()", "lld/MachO/SyntheticSections.cpp", 346
, __extension__ __PRETTY_FUNCTION__))
;
347 sym->gotIndex = entries.size() - 1;
348
349 addNonLazyBindingEntries(sym, isec, sym->gotIndex * target->wordSize);
350 }
351}
352
353void macho::writeChainedRebase(uint8_t *buf, uint64_t targetVA) {
354 assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
(0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 354, __extension__ __PRETTY_FUNCTION__))
;
355 assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
"Only 64-bit platforms are supported") ? void (0) : __assert_fail
("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 355, __extension__ __PRETTY_FUNCTION__
))
;
356 auto *rebase = reinterpret_cast<dyld_chained_ptr_64_rebase *>(buf);
357 rebase->target = targetVA & 0xf'ffff'ffff;
358 rebase->high8 = (targetVA >> 56);
359 rebase->reserved = 0;
360 rebase->next = 0;
361 rebase->bind = 0;
362
363 // The fixup format places a 64 GiB limit on the output's size.
364 // Should we handle this gracefully?
365 uint64_t encodedVA = rebase->target | ((uint64_t)rebase->high8 << 56);
366 if (encodedVA != targetVA)
367 error("rebase target address 0x" + Twine::utohexstr(targetVA) +
368 " does not fit into chained fixup. Re-link with -no_fixup_chains");
369}
370
371static void writeChainedBind(uint8_t *buf, const Symbol *sym, int64_t addend) {
372 assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
(0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 372, __extension__ __PRETTY_FUNCTION__))
;
373 assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
"Only 64-bit platforms are supported") ? void (0) : __assert_fail
("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 373, __extension__ __PRETTY_FUNCTION__
))
;
374 auto *bind = reinterpret_cast<dyld_chained_ptr_64_bind *>(buf);
375 auto [ordinal, inlineAddend] = in.chainedFixups->getBinding(sym, addend);
376 bind->ordinal = ordinal;
377 bind->addend = inlineAddend;
378 bind->reserved = 0;
379 bind->next = 0;
380 bind->bind = 1;
381}
382
383void macho::writeChainedFixup(uint8_t *buf, const Symbol *sym, int64_t addend) {
384 if (needsBinding(sym))
385 writeChainedBind(buf, sym, addend);
386 else
387 writeChainedRebase(buf, sym->getVA() + addend);
388}
389
390void NonLazyPointerSectionBase::writeTo(uint8_t *buf) const {
391 if (config->emitChainedFixups) {
392 for (const auto &[i, entry] : llvm::enumerate(entries))
393 writeChainedFixup(&buf[i * target->wordSize], entry, 0);
394 } else {
395 for (const auto &[i, entry] : llvm::enumerate(entries))
396 if (auto *defined = dyn_cast<Defined>(entry))
397 write64le(&buf[i * target->wordSize], defined->getVA());
398 }
399}
400
401GotSection::GotSection()
402 : NonLazyPointerSectionBase(segment_names::data, section_names::got) {
403 flags = S_NON_LAZY_SYMBOL_POINTERS;
404}
405
406TlvPointerSection::TlvPointerSection()
407 : NonLazyPointerSectionBase(segment_names::data,
408 section_names::threadPtrs) {
409 flags = S_THREAD_LOCAL_VARIABLE_POINTERS;
410}
411
412BindingSection::BindingSection()
413 : LinkEditSection(segment_names::linkEdit, section_names::binding) {}
414
415namespace {
416struct Binding {
417 OutputSegment *segment = nullptr;
418 uint64_t offset = 0;
419 int64_t addend = 0;
420};
421struct BindIR {
422 // Default value of 0xF0 is not valid opcode and should make the program
423 // scream instead of accidentally writing "valid" values.
424 uint8_t opcode = 0xF0;
425 uint64_t data = 0;
426 uint64_t consecutiveCount = 0;
427};
428} // namespace
429
430// Encode a sequence of opcodes that tell dyld to write the address of symbol +
431// addend at osec->addr + outSecOff.
432//
433// The bind opcode "interpreter" remembers the values of each binding field, so
434// we only need to encode the differences between bindings. Hence the use of
435// lastBinding.
436static void encodeBinding(const OutputSection *osec, uint64_t outSecOff,
437 int64_t addend, Binding &lastBinding,
438 std::vector<BindIR> &opcodes) {
439 OutputSegment *seg = osec->parent;
440 uint64_t offset = osec->getSegmentOffset() + outSecOff;
441 if (lastBinding.segment != seg) {
442 opcodes.push_back(
443 {static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
444 seg->index),
445 offset});
446 lastBinding.segment = seg;
447 lastBinding.offset = offset;
448 } else if (lastBinding.offset != offset) {
449 opcodes.push_back({BIND_OPCODE_ADD_ADDR_ULEB, offset - lastBinding.offset});
450 lastBinding.offset = offset;
451 }
452
453 if (lastBinding.addend != addend) {
454 opcodes.push_back(
455 {BIND_OPCODE_SET_ADDEND_SLEB, static_cast<uint64_t>(addend)});
456 lastBinding.addend = addend;
457 }
458
459 opcodes.push_back({BIND_OPCODE_DO_BIND, 0});
460 // DO_BIND causes dyld to both perform the binding and increment the offset
461 lastBinding.offset += target->wordSize;
462}
463
464static void optimizeOpcodes(std::vector<BindIR> &opcodes) {
465 // Pass 1: Combine bind/add pairs
466 size_t i;
467 int pWrite = 0;
468 for (i = 1; i < opcodes.size(); ++i, ++pWrite) {
469 if ((opcodes[i].opcode == BIND_OPCODE_ADD_ADDR_ULEB) &&
470 (opcodes[i - 1].opcode == BIND_OPCODE_DO_BIND)) {
471 opcodes[pWrite].opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB;
472 opcodes[pWrite].data = opcodes[i].data;
473 ++i;
474 } else {
475 opcodes[pWrite] = opcodes[i - 1];
476 }
477 }
478 if (i == opcodes.size())
479 opcodes[pWrite] = opcodes[i - 1];
480 opcodes.resize(pWrite + 1);
481
482 // Pass 2: Compress two or more bind_add opcodes
483 pWrite = 0;
484 for (i = 1; i < opcodes.size(); ++i, ++pWrite) {
485 if ((opcodes[i].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
486 (opcodes[i - 1].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
487 (opcodes[i].data == opcodes[i - 1].data)) {
488 opcodes[pWrite].opcode = BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB;
489 opcodes[pWrite].consecutiveCount = 2;
490 opcodes[pWrite].data = opcodes[i].data;
491 ++i;
492 while (i < opcodes.size() &&
493 (opcodes[i].opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
494 (opcodes[i].data == opcodes[i - 1].data)) {
495 opcodes[pWrite].consecutiveCount++;
496 ++i;
497 }
498 } else {
499 opcodes[pWrite] = opcodes[i - 1];
500 }
501 }
502 if (i == opcodes.size())
503 opcodes[pWrite] = opcodes[i - 1];
504 opcodes.resize(pWrite + 1);
505
506 // Pass 3: Use immediate encodings
507 // Every binding is the size of one pointer. If the next binding is a
508 // multiple of wordSize away that is within BIND_IMMEDIATE_MASK, the
509 // opcode can be scaled by wordSize into a single byte and dyld will
510 // expand it to the correct address.
511 for (auto &p : opcodes) {
512 // It's unclear why the check needs to be less than BIND_IMMEDIATE_MASK,
513 // but ld64 currently does this. This could be a potential bug, but
514 // for now, perform the same behavior to prevent mysterious bugs.
515 if ((p.opcode == BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB) &&
516 ((p.data / target->wordSize) < BIND_IMMEDIATE_MASK) &&
517 ((p.data % target->wordSize) == 0)) {
518 p.opcode = BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED;
519 p.data /= target->wordSize;
520 }
521 }
522}
523
524static void flushOpcodes(const BindIR &op, raw_svector_ostream &os) {
525 uint8_t opcode = op.opcode & BIND_OPCODE_MASK;
526 switch (opcode) {
527 case BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB:
528 case BIND_OPCODE_ADD_ADDR_ULEB:
529 case BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB:
530 os << op.opcode;
531 encodeULEB128(op.data, os);
532 break;
533 case BIND_OPCODE_SET_ADDEND_SLEB:
534 os << op.opcode;
535 encodeSLEB128(static_cast<int64_t>(op.data), os);
536 break;
537 case BIND_OPCODE_DO_BIND:
538 os << op.opcode;
539 break;
540 case BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB:
541 os << op.opcode;
542 encodeULEB128(op.consecutiveCount, os);
543 encodeULEB128(op.data, os);
544 break;
545 case BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED:
546 os << static_cast<uint8_t>(op.opcode | op.data);
547 break;
548 default:
549 llvm_unreachable("cannot bind to an unrecognized symbol")::llvm::llvm_unreachable_internal("cannot bind to an unrecognized symbol"
, "lld/MachO/SyntheticSections.cpp", 549)
;
550 }
551}
552
553// Non-weak bindings need to have their dylib ordinal encoded as well.
554static int16_t ordinalForDylibSymbol(const DylibSymbol &dysym) {
555 if (config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup())
556 return static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP);
557 assert(dysym.getFile()->isReferenced())(static_cast <bool> (dysym.getFile()->isReferenced()
) ? void (0) : __assert_fail ("dysym.getFile()->isReferenced()"
, "lld/MachO/SyntheticSections.cpp", 557, __extension__ __PRETTY_FUNCTION__
))
;
558 return dysym.getFile()->ordinal;
559}
560
561static int16_t ordinalForSymbol(const Symbol &sym) {
562 if (const auto *dysym = dyn_cast<DylibSymbol>(&sym))
563 return ordinalForDylibSymbol(*dysym);
564 assert(cast<Defined>(&sym)->interposable)(static_cast <bool> (cast<Defined>(&sym)->
interposable) ? void (0) : __assert_fail ("cast<Defined>(&sym)->interposable"
, "lld/MachO/SyntheticSections.cpp", 564, __extension__ __PRETTY_FUNCTION__
))
;
565 return BIND_SPECIAL_DYLIB_FLAT_LOOKUP;
566}
567
568static void encodeDylibOrdinal(int16_t ordinal, raw_svector_ostream &os) {
569 if (ordinal <= 0) {
570 os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
571 (ordinal & BIND_IMMEDIATE_MASK));
572 } else if (ordinal <= BIND_IMMEDIATE_MASK) {
573 os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);
574 } else {
575 os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
576 encodeULEB128(ordinal, os);
577 }
578}
579
580static void encodeWeakOverride(const Defined *defined,
581 raw_svector_ostream &os) {
582 os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
583 BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
584 << defined->getName() << '\0';
585}
586
587// Organize the bindings so we can encoded them with fewer opcodes.
588//
589// First, all bindings for a given symbol should be grouped together.
590// BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM is the largest opcode (since it
591// has an associated symbol string), so we only want to emit it once per symbol.
592//
593// Within each group, we sort the bindings by address. Since bindings are
594// delta-encoded, sorting them allows for a more compact result. Note that
595// sorting by address alone ensures that bindings for the same segment / section
596// are located together, minimizing the number of times we have to emit
597// BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB.
598//
599// Finally, we sort the symbols by the address of their first binding, again
600// to facilitate the delta-encoding process.
601template <class Sym>
602std::vector<std::pair<const Sym *, std::vector<BindingEntry>>>
603sortBindings(const BindingsMap<const Sym *> &bindingsMap) {
604 std::vector<std::pair<const Sym *, std::vector<BindingEntry>>> bindingsVec(
605 bindingsMap.begin(), bindingsMap.end());
606 for (auto &p : bindingsVec) {
607 std::vector<BindingEntry> &bindings = p.second;
608 llvm::sort(bindings, [](const BindingEntry &a, const BindingEntry &b) {
609 return a.target.getVA() < b.target.getVA();
610 });
611 }
612 llvm::sort(bindingsVec, [](const auto &a, const auto &b) {
613 return a.second[0].target.getVA() < b.second[0].target.getVA();
614 });
615 return bindingsVec;
616}
617
618// Emit bind opcodes, which are a stream of byte-sized opcodes that dyld
619// interprets to update a record with the following fields:
620// * segment index (of the segment to write the symbol addresses to, typically
621// the __DATA_CONST segment which contains the GOT)
622// * offset within the segment, indicating the next location to write a binding
623// * symbol type
624// * symbol library ordinal (the index of its library's LC_LOAD_DYLIB command)
625// * symbol name
626// * addend
627// When dyld sees BIND_OPCODE_DO_BIND, it uses the current record state to bind
628// a symbol in the GOT, and increments the segment offset to point to the next
629// entry. It does *not* clear the record state after doing the bind, so
630// subsequent opcodes only need to encode the differences between bindings.
631void BindingSection::finalizeContents() {
632 raw_svector_ostream os{contents};
633 Binding lastBinding;
634 int16_t lastOrdinal = 0;
635
636 for (auto &p : sortBindings(bindingsMap)) {
637 const Symbol *sym = p.first;
638 std::vector<BindingEntry> &bindings = p.second;
639 uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
640 if (sym->isWeakRef())
641 flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
642 os << flags << sym->getName() << '\0'
643 << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
644 int16_t ordinal = ordinalForSymbol(*sym);
645 if (ordinal != lastOrdinal) {
646 encodeDylibOrdinal(ordinal, os);
647 lastOrdinal = ordinal;
648 }
649 std::vector<BindIR> opcodes;
650 for (const BindingEntry &b : bindings)
651 encodeBinding(b.target.isec->parent,
652 b.target.isec->getOffset(b.target.offset), b.addend,
653 lastBinding, opcodes);
654 if (config->optimize > 1)
655 optimizeOpcodes(opcodes);
656 for (const auto &op : opcodes)
657 flushOpcodes(op, os);
658 }
659 if (!bindingsMap.empty())
660 os << static_cast<uint8_t>(BIND_OPCODE_DONE);
661}
662
663void BindingSection::writeTo(uint8_t *buf) const {
664 memcpy(buf, contents.data(), contents.size());
665}
666
667WeakBindingSection::WeakBindingSection()
668 : LinkEditSection(segment_names::linkEdit, section_names::weakBinding) {}
669
670void WeakBindingSection::finalizeContents() {
671 raw_svector_ostream os{contents};
672 Binding lastBinding;
673
674 for (const Defined *defined : definitions)
675 encodeWeakOverride(defined, os);
676
677 for (auto &p : sortBindings(bindingsMap)) {
678 const Symbol *sym = p.first;
679 std::vector<BindingEntry> &bindings = p.second;
680 os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
681 << sym->getName() << '\0'
682 << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
683 std::vector<BindIR> opcodes;
684 for (const BindingEntry &b : bindings)
685 encodeBinding(b.target.isec->parent,
686 b.target.isec->getOffset(b.target.offset), b.addend,
687 lastBinding, opcodes);
688 if (config->optimize > 1)
689 optimizeOpcodes(opcodes);
690 for (const auto &op : opcodes)
691 flushOpcodes(op, os);
692 }
693 if (!bindingsMap.empty() || !definitions.empty())
694 os << static_cast<uint8_t>(BIND_OPCODE_DONE);
695}
696
697void WeakBindingSection::writeTo(uint8_t *buf) const {
698 memcpy(buf, contents.data(), contents.size());
699}
700
701StubsSection::StubsSection()
702 : SyntheticSection(segment_names::text, section_names::stubs) {
703 flags = S_SYMBOL_STUBS | S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
704 // The stubs section comprises machine instructions, which are aligned to
705 // 4 bytes on the archs we care about.
706 align = 4;
707 reserved2 = target->stubSize;
708}
709
710uint64_t StubsSection::getSize() const {
711 return entries.size() * target->stubSize;
712}
713
714void StubsSection::writeTo(uint8_t *buf) const {
715 size_t off = 0;
716 for (const Symbol *sym : entries) {
717 uint64_t pointerVA =
718 config->emitChainedFixups ? sym->getGotVA() : sym->getLazyPtrVA();
719 target->writeStub(buf + off, *sym, pointerVA);
720 off += target->stubSize;
721 }
722}
723
724void StubsSection::finalize() { isFinal = true; }
725
726static void addBindingsForStub(Symbol *sym) {
727 assert(!config->emitChainedFixups)(static_cast <bool> (!config->emitChainedFixups) ? void
(0) : __assert_fail ("!config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 727, __extension__ __PRETTY_FUNCTION__))
;
728 if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
729 if (sym->isWeakDef()) {
730 in.binding->addEntry(dysym, in.lazyPointers->isec,
731 sym->stubsIndex * target->wordSize);
732 in.weakBinding->addEntry(sym, in.lazyPointers->isec,
733 sym->stubsIndex * target->wordSize);
734 } else {
735 in.lazyBinding->addEntry(dysym);
736 }
737 } else if (auto *defined = dyn_cast<Defined>(sym)) {
738 if (defined->isExternalWeakDef()) {
739 in.rebase->addEntry(in.lazyPointers->isec,
740 sym->stubsIndex * target->wordSize);
741 in.weakBinding->addEntry(sym, in.lazyPointers->isec,
742 sym->stubsIndex * target->wordSize);
743 } else if (defined->interposable) {
744 in.lazyBinding->addEntry(sym);
745 } else {
746 llvm_unreachable("invalid stub target")::llvm::llvm_unreachable_internal("invalid stub target", "lld/MachO/SyntheticSections.cpp"
, 746)
;
747 }
748 } else {
749 llvm_unreachable("invalid stub target symbol type")::llvm::llvm_unreachable_internal("invalid stub target symbol type"
, "lld/MachO/SyntheticSections.cpp", 749)
;
750 }
751}
752
753void StubsSection::addEntry(Symbol *sym) {
754 bool inserted = entries.insert(sym);
755 if (inserted) {
756 sym->stubsIndex = entries.size() - 1;
757
758 if (config->emitChainedFixups)
759 in.got->addEntry(sym);
760 else
761 addBindingsForStub(sym);
762 }
763}
764
765StubHelperSection::StubHelperSection()
766 : SyntheticSection(segment_names::text, section_names::stubHelper) {
767 flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
768 align = 4; // This section comprises machine instructions
769}
770
771uint64_t StubHelperSection::getSize() const {
772 return target->stubHelperHeaderSize +
773 in.lazyBinding->getEntries().size() * target->stubHelperEntrySize;
774}
775
776bool StubHelperSection::isNeeded() const { return in.lazyBinding->isNeeded(); }
777
778void StubHelperSection::writeTo(uint8_t *buf) const {
779 target->writeStubHelperHeader(buf);
780 size_t off = target->stubHelperHeaderSize;
781 for (const Symbol *sym : in.lazyBinding->getEntries()) {
782 target->writeStubHelperEntry(buf + off, *sym, addr + off);
783 off += target->stubHelperEntrySize;
784 }
785}
786
787void StubHelperSection::setUp() {
788 Symbol *binder = symtab->addUndefined("dyld_stub_binder", /*file=*/nullptr,
789 /*isWeakRef=*/false);
790 if (auto *undefined = dyn_cast<Undefined>(binder))
791 treatUndefinedSymbol(*undefined,
792 "lazy binding (normally in libSystem.dylib)");
793
794 // treatUndefinedSymbol() can replace binder with a DylibSymbol; re-check.
795 stubBinder = dyn_cast_or_null<DylibSymbol>(binder);
796 if (stubBinder == nullptr)
797 return;
798
799 in.got->addEntry(stubBinder);
800
801 in.imageLoaderCache->parent =
802 ConcatOutputSection::getOrCreateForInput(in.imageLoaderCache);
803 inputSections.push_back(in.imageLoaderCache);
804 // Since this isn't in the symbol table or in any input file, the noDeadStrip
805 // argument doesn't matter.
806 dyldPrivate =
807 make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
808 /*isWeakDef=*/false,
809 /*isExternal=*/false, /*isPrivateExtern=*/false,
810 /*includeInSymtab=*/true,
811 /*isThumb=*/false, /*isReferencedDynamically=*/false,
812 /*noDeadStrip=*/false);
813 dyldPrivate->used = true;
814}
815
816ObjCStubsSection::ObjCStubsSection()
817 : SyntheticSection(segment_names::text, section_names::objcStubs) {
818 flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
819 align = target->objcStubsAlignment;
820}
821
822void ObjCStubsSection::addEntry(Symbol *sym) {
823 assert(sym->getName().startswith(symbolPrefix) && "not an objc stub")(static_cast <bool> (sym->getName().startswith(symbolPrefix
) && "not an objc stub") ? void (0) : __assert_fail (
"sym->getName().startswith(symbolPrefix) && \"not an objc stub\""
, "lld/MachO/SyntheticSections.cpp", 823, __extension__ __PRETTY_FUNCTION__
))
;
824 StringRef methname = sym->getName().drop_front(symbolPrefix.size());
825 offsets.push_back(
826 in.objcMethnameSection->getStringOffset(methname).outSecOff);
827 Defined *newSym = replaceSymbol<Defined>(
828 sym, sym->getName(), nullptr, isec,
829 /*value=*/symbols.size() * target->objcStubsFastSize,
830 /*size=*/target->objcStubsFastSize,
831 /*isWeakDef=*/false, /*isExternal=*/true, /*isPrivateExtern=*/true,
832 /*includeInSymtab=*/true, /*isThumb=*/false,
833 /*isReferencedDynamically=*/false, /*noDeadStrip=*/false);
834 symbols.push_back(newSym);
835}
836
837void ObjCStubsSection::setUp() {
838 Symbol *objcMsgSend = symtab->addUndefined("_objc_msgSend", /*file=*/nullptr,
839 /*isWeakRef=*/false);
840 objcMsgSend->used = true;
841 in.got->addEntry(objcMsgSend);
842 assert(objcMsgSend->isInGot())(static_cast <bool> (objcMsgSend->isInGot()) ? void (
0) : __assert_fail ("objcMsgSend->isInGot()", "lld/MachO/SyntheticSections.cpp"
, 842, __extension__ __PRETTY_FUNCTION__))
;
843 objcMsgSendGotIndex = objcMsgSend->gotIndex;
844
845 size_t size = offsets.size() * target->wordSize;
846 uint8_t *selrefsData = bAlloc().Allocate<uint8_t>(size);
847 for (size_t i = 0, n = offsets.size(); i < n; ++i)
848 write64le(&selrefsData[i * target->wordSize], offsets[i]);
849
850 in.objcSelrefs =
851 makeSyntheticInputSection(segment_names::data, section_names::objcSelrefs,
852 S_LITERAL_POINTERS | S_ATTR_NO_DEAD_STRIP,
853 ArrayRef<uint8_t>{selrefsData, size},
854 /*align=*/target->wordSize);
855 in.objcSelrefs->live = true;
856
857 for (size_t i = 0, n = offsets.size(); i < n; ++i) {
858 in.objcSelrefs->relocs.push_back(
859 {/*type=*/target->unsignedRelocType,
860 /*pcrel=*/false, /*length=*/3,
861 /*offset=*/static_cast<uint32_t>(i * target->wordSize),
862 /*addend=*/offsets[i] * in.objcMethnameSection->align,
863 /*referent=*/in.objcMethnameSection->isec});
864 }
865
866 in.objcSelrefs->parent =
867 ConcatOutputSection::getOrCreateForInput(in.objcSelrefs);
868 inputSections.push_back(in.objcSelrefs);
869 in.objcSelrefs->isFinal = true;
870}
871
872uint64_t ObjCStubsSection::getSize() const {
873 return target->objcStubsFastSize * symbols.size();
874}
875
876void ObjCStubsSection::writeTo(uint8_t *buf) const {
877 assert(in.objcSelrefs->live)(static_cast <bool> (in.objcSelrefs->live) ? void (0
) : __assert_fail ("in.objcSelrefs->live", "lld/MachO/SyntheticSections.cpp"
, 877, __extension__ __PRETTY_FUNCTION__))
;
878 assert(in.objcSelrefs->isFinal)(static_cast <bool> (in.objcSelrefs->isFinal) ? void
(0) : __assert_fail ("in.objcSelrefs->isFinal", "lld/MachO/SyntheticSections.cpp"
, 878, __extension__ __PRETTY_FUNCTION__))
;
879
880 uint64_t stubOffset = 0;
881 for (size_t i = 0, n = symbols.size(); i < n; ++i) {
882 Defined *sym = symbols[i];
883 target->writeObjCMsgSendStub(buf + stubOffset, sym, in.objcStubs->addr,
884 stubOffset, in.objcSelrefs->getVA(), i,
885 in.got->addr, objcMsgSendGotIndex);
886 stubOffset += target->objcStubsFastSize;
887 }
888}
889
890LazyPointerSection::LazyPointerSection()
891 : SyntheticSection(segment_names::data, section_names::lazySymbolPtr) {
892 align = target->wordSize;
893 flags = S_LAZY_SYMBOL_POINTERS;
894}
895
896uint64_t LazyPointerSection::getSize() const {
897 return in.stubs->getEntries().size() * target->wordSize;
898}
899
900bool LazyPointerSection::isNeeded() const {
901 return !in.stubs->getEntries().empty();
902}
903
904void LazyPointerSection::writeTo(uint8_t *buf) const {
905 size_t off = 0;
906 for (const Symbol *sym : in.stubs->getEntries()) {
907 if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
908 if (dysym->hasStubsHelper()) {
909 uint64_t stubHelperOffset =
910 target->stubHelperHeaderSize +
911 dysym->stubsHelperIndex * target->stubHelperEntrySize;
912 write64le(buf + off, in.stubHelper->addr + stubHelperOffset);
913 }
914 } else {
915 write64le(buf + off, sym->getVA());
916 }
917 off += target->wordSize;
918 }
919}
920
921LazyBindingSection::LazyBindingSection()
922 : LinkEditSection(segment_names::linkEdit, section_names::lazyBinding) {}
923
924void LazyBindingSection::finalizeContents() {
925 // TODO: Just precompute output size here instead of writing to a temporary
926 // buffer
927 for (Symbol *sym : entries)
928 sym->lazyBindOffset = encode(*sym);
929}
930
931void LazyBindingSection::writeTo(uint8_t *buf) const {
932 memcpy(buf, contents.data(), contents.size());
933}
934
935void LazyBindingSection::addEntry(Symbol *sym) {
936 assert(!config->emitChainedFixups && "Chained fixups always bind eagerly")(static_cast <bool> (!config->emitChainedFixups &&
"Chained fixups always bind eagerly") ? void (0) : __assert_fail
("!config->emitChainedFixups && \"Chained fixups always bind eagerly\""
, "lld/MachO/SyntheticSections.cpp", 936, __extension__ __PRETTY_FUNCTION__
))
;
937 if (entries.insert(sym)) {
938 sym->stubsHelperIndex = entries.size() - 1;
939 in.rebase->addEntry(in.lazyPointers->isec,
940 sym->stubsIndex * target->wordSize);
941 }
942}
943
944// Unlike the non-lazy binding section, the bind opcodes in this section aren't
945// interpreted all at once. Rather, dyld will start interpreting opcodes at a
946// given offset, typically only binding a single symbol before it finds a
947// BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
948// we cannot encode just the differences between symbols; we have to emit the
949// complete bind information for each symbol.
950uint32_t LazyBindingSection::encode(const Symbol &sym) {
951 uint32_t opstreamOffset = contents.size();
952 OutputSegment *dataSeg = in.lazyPointers->parent;
953 os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
954 dataSeg->index);
955 uint64_t offset =
956 in.lazyPointers->addr - dataSeg->addr + sym.stubsIndex * target->wordSize;
957 encodeULEB128(offset, os);
958 encodeDylibOrdinal(ordinalForSymbol(sym), os);
959
960 uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
961 if (sym.isWeakRef())
962 flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
963
964 os << flags << sym.getName() << '\0'
965 << static_cast<uint8_t>(BIND_OPCODE_DO_BIND)
966 << static_cast<uint8_t>(BIND_OPCODE_DONE);
967 return opstreamOffset;
968}
969
970ExportSection::ExportSection()
971 : LinkEditSection(segment_names::linkEdit, section_names::export_) {}
972
973void ExportSection::finalizeContents() {
974 trieBuilder.setImageBase(in.header->addr);
975 for (const Symbol *sym : symtab->getSymbols()) {
976 if (const auto *defined = dyn_cast<Defined>(sym)) {
977 if (defined->privateExtern || !defined->isLive())
978 continue;
979 trieBuilder.addSymbol(*defined);
980 hasWeakSymbol = hasWeakSymbol || sym->isWeakDef();
981 } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
982 if (dysym->shouldReexport)
983 trieBuilder.addSymbol(*dysym);
984 }
985 }
986 size = trieBuilder.build();
987}
988
989void ExportSection::writeTo(uint8_t *buf) const { trieBuilder.writeTo(buf); }
990
991DataInCodeSection::DataInCodeSection()
992 : LinkEditSection(segment_names::linkEdit, section_names::dataInCode) {}
993
994template <class LP>
995static std::vector<MachO::data_in_code_entry> collectDataInCodeEntries() {
996 std::vector<MachO::data_in_code_entry> dataInCodeEntries;
997 for (const InputFile *inputFile : inputFiles) {
998 if (!isa<ObjFile>(inputFile))
999 continue;
1000 const ObjFile *objFile = cast<ObjFile>(inputFile);
1001 ArrayRef<MachO::data_in_code_entry> entries = objFile->getDataInCode();
1002 if (entries.empty())
1003 continue;
1004
1005 assert(is_sorted(entries, [](const data_in_code_entry &lhs,(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
&lhs, const data_in_code_entry &rhs) { return lhs.offset
< rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
1006 const data_in_code_entry &rhs) {(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
&lhs, const data_in_code_entry &rhs) { return lhs.offset
< rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
1007 return lhs.offset < rhs.offset;(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
&lhs, const data_in_code_entry &rhs) { return lhs.offset
< rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
1008 }))(static_cast <bool> (is_sorted(entries, [](const data_in_code_entry
&lhs, const data_in_code_entry &rhs) { return lhs.offset
< rhs.offset; })) ? void (0) : __assert_fail ("is_sorted(entries, [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) { return lhs.offset < rhs.offset; })"
, "lld/MachO/SyntheticSections.cpp", 1008, __extension__ __PRETTY_FUNCTION__
))
;
1009 // For each code subsection find 'data in code' entries residing in it.
1010 // Compute the new offset values as
1011 // <offset within subsection> + <subsection address> - <__TEXT address>.
1012 for (const Section *section : objFile->sections) {
1013 for (const Subsection &subsec : section->subsections) {
1014 const InputSection *isec = subsec.isec;
1015 if (!isCodeSection(isec))
1016 continue;
1017 if (cast<ConcatInputSection>(isec)->shouldOmitFromOutput())
1018 continue;
1019 const uint64_t beginAddr = section->addr + subsec.offset;
1020 auto it = llvm::lower_bound(
1021 entries, beginAddr,
1022 [](const MachO::data_in_code_entry &entry, uint64_t addr) {
1023 return entry.offset < addr;
1024 });
1025 const uint64_t endAddr = beginAddr + isec->getSize();
1026 for (const auto end = entries.end();
1027 it != end && it->offset + it->length <= endAddr; ++it)
1028 dataInCodeEntries.push_back(
1029 {static_cast<uint32_t>(isec->getVA(it->offset - beginAddr) -
1030 in.header->addr),
1031 it->length, it->kind});
1032 }
1033 }
1034 }
1035
1036 // ld64 emits the table in sorted order too.
1037 llvm::sort(dataInCodeEntries,
1038 [](const data_in_code_entry &lhs, const data_in_code_entry &rhs) {
1039 return lhs.offset < rhs.offset;
1040 });
1041 return dataInCodeEntries;
1042}
1043
1044void DataInCodeSection::finalizeContents() {
1045 entries = target->wordSize == 8 ? collectDataInCodeEntries<LP64>()
1046 : collectDataInCodeEntries<ILP32>();
1047}
1048
1049void DataInCodeSection::writeTo(uint8_t *buf) const {
1050 if (!entries.empty())
1051 memcpy(buf, entries.data(), getRawSize());
1052}
1053
1054FunctionStartsSection::FunctionStartsSection()
1055 : LinkEditSection(segment_names::linkEdit, section_names::functionStarts) {}
1056
1057void FunctionStartsSection::finalizeContents() {
1058 raw_svector_ostream os{contents};
1059 std::vector<uint64_t> addrs;
1060 for (const InputFile *file : inputFiles) {
1061 if (auto *objFile = dyn_cast<ObjFile>(file)) {
1062 for (const Symbol *sym : objFile->symbols) {
1063 if (const auto *defined = dyn_cast_or_null<Defined>(sym)) {
1064 if (!defined->isec || !isCodeSection(defined->isec) ||
1065 !defined->isLive())
1066 continue;
1067 // TODO: Add support for thumbs, in that case
1068 // the lowest bit of nextAddr needs to be set to 1.
1069 addrs.push_back(defined->getVA());
1070 }
1071 }
1072 }
1073 }
1074 llvm::sort(addrs);
1075 uint64_t addr = in.header->addr;
1076 for (uint64_t nextAddr : addrs) {
1077 uint64_t delta = nextAddr - addr;
1078 if (delta == 0)
1079 continue;
1080 encodeULEB128(delta, os);
1081 addr = nextAddr;
1082 }
1083 os << '\0';
1084}
1085
1086void FunctionStartsSection::writeTo(uint8_t *buf) const {
1087 memcpy(buf, contents.data(), contents.size());
1088}
1089
1090SymtabSection::SymtabSection(StringTableSection &stringTableSection)
1091 : LinkEditSection(segment_names::linkEdit, section_names::symbolTable),
1092 stringTableSection(stringTableSection) {}
1093
1094void SymtabSection::emitBeginSourceStab(StringRef sourceFile) {
1095 StabsEntry stab(N_SO);
1096 stab.strx = stringTableSection.addString(saver().save(sourceFile));
1097 stabs.emplace_back(std::move(stab));
1098}
1099
1100void SymtabSection::emitEndSourceStab() {
1101 StabsEntry stab(N_SO);
1102 stab.sect = 1;
1103 stabs.emplace_back(std::move(stab));
1104}
1105
1106void SymtabSection::emitObjectFileStab(ObjFile *file) {
1107 StabsEntry stab(N_OSO);
1108 stab.sect = target->cpuSubtype;
1109 SmallString<261> path(!file->archiveName.empty() ? file->archiveName
1110 : file->getName());
1111 std::error_code ec = sys::fs::make_absolute(path);
1112 if (ec)
1113 fatal("failed to get absolute path for " + path);
1114
1115 if (!file->archiveName.empty())
1116 path.append({"(", file->getName(), ")"});
1117
1118 StringRef adjustedPath = saver().save(path.str());
1119 adjustedPath.consume_front(config->osoPrefix);
1120
1121 stab.strx = stringTableSection.addString(adjustedPath);
1122 stab.desc = 1;
1123 stab.value = file->modTime;
1124 stabs.emplace_back(std::move(stab));
1125}
1126
1127void SymtabSection::emitEndFunStab(Defined *defined) {
1128 StabsEntry stab(N_FUN);
1129 stab.value = defined->size;
1130 stabs.emplace_back(std::move(stab));
1131}
1132
1133void SymtabSection::emitStabs() {
1134 if (config->omitDebugInfo)
1135 return;
1136
1137 for (const std::string &s : config->astPaths) {
1138 StabsEntry astStab(N_AST);
1139 astStab.strx = stringTableSection.addString(s);
1140 stabs.emplace_back(std::move(astStab));
1141 }
1142
1143 // Cache the file ID for each symbol in an std::pair for faster sorting.
1144 using SortingPair = std::pair<Defined *, int>;
1145 std::vector<SortingPair> symbolsNeedingStabs;
1146 for (const SymtabEntry &entry :
1147 concat<SymtabEntry>(localSymbols, externalSymbols)) {
1148 Symbol *sym = entry.sym;
1149 assert(sym->isLive() &&(static_cast <bool> (sym->isLive() && "dead symbols should not be in localSymbols, externalSymbols"
) ? void (0) : __assert_fail ("sym->isLive() && \"dead symbols should not be in localSymbols, externalSymbols\""
, "lld/MachO/SyntheticSections.cpp", 1150, __extension__ __PRETTY_FUNCTION__
))
1150 "dead symbols should not be in localSymbols, externalSymbols")(static_cast <bool> (sym->isLive() && "dead symbols should not be in localSymbols, externalSymbols"
) ? void (0) : __assert_fail ("sym->isLive() && \"dead symbols should not be in localSymbols, externalSymbols\""
, "lld/MachO/SyntheticSections.cpp", 1150, __extension__ __PRETTY_FUNCTION__
))
;
1151 if (auto *defined = dyn_cast<Defined>(sym)) {
1152 // Excluded symbols should have been filtered out in finalizeContents().
1153 assert(defined->includeInSymtab)(static_cast <bool> (defined->includeInSymtab) ? void
(0) : __assert_fail ("defined->includeInSymtab", "lld/MachO/SyntheticSections.cpp"
, 1153, __extension__ __PRETTY_FUNCTION__))
;
1154
1155 if (defined->isAbsolute())
1156 continue;
1157
1158 // Constant-folded symbols go in the executable's symbol table, but don't
1159 // get a stabs entry.
1160 if (defined->wasIdenticalCodeFolded)
1161 continue;
1162
1163 ObjFile *file = defined->getObjectFile();
1164 if (!file || !file->compileUnit)
1165 continue;
1166
1167 symbolsNeedingStabs.emplace_back(defined, defined->isec->getFile()->id);
1168 }
1169 }
1170
1171 llvm::stable_sort(symbolsNeedingStabs,
1172 [&](const SortingPair &a, const SortingPair &b) {
1173 return a.second < b.second;
1174 });
1175
1176 // Emit STABS symbols so that dsymutil and/or the debugger can map address
1177 // regions in the final binary to the source and object files from which they
1178 // originated.
1179 InputFile *lastFile = nullptr;
1180 for (SortingPair &pair : symbolsNeedingStabs) {
1181 Defined *defined = pair.first;
1182 InputSection *isec = defined->isec;
1183 ObjFile *file = cast<ObjFile>(isec->getFile());
1184
1185 if (lastFile == nullptr || lastFile != file) {
1186 if (lastFile != nullptr)
1187 emitEndSourceStab();
1188 lastFile = file;
1189
1190 emitBeginSourceStab(file->sourceFile());
1191 emitObjectFileStab(file);
1192 }
1193
1194 StabsEntry symStab;
1195 symStab.sect = defined->isec->parent->index;
1196 symStab.strx = stringTableSection.addString(defined->getName());
1197 symStab.value = defined->getVA();
1198
1199 if (isCodeSection(isec)) {
1200 symStab.type = N_FUN;
1201 stabs.emplace_back(std::move(symStab));
1202 emitEndFunStab(defined);
1203 } else {
1204 symStab.type = defined->isExternal() ? N_GSYM : N_STSYM;
1205 stabs.emplace_back(std::move(symStab));
1206 }
1207 }
1208
1209 if (!stabs.empty())
1210 emitEndSourceStab();
1211}
1212
1213void SymtabSection::finalizeContents() {
1214 auto addSymbol = [&](std::vector<SymtabEntry> &symbols, Symbol *sym) {
1215 uint32_t strx = stringTableSection.addString(sym->getName());
1216 symbols.push_back({sym, strx});
1217 };
1218
1219 std::function<void(Symbol *)> localSymbolsHandler;
1220 switch (config->localSymbolsPresence) {
1221 case SymtabPresence::All:
1222 localSymbolsHandler = [&](Symbol *sym) { addSymbol(localSymbols, sym); };
1223 break;
1224 case SymtabPresence::None:
1225 localSymbolsHandler = [&](Symbol *) { /* Do nothing*/ };
1226 break;
1227 case SymtabPresence::SelectivelyIncluded:
1228 localSymbolsHandler = [&](Symbol *sym) {
1229 if (config->localSymbolPatterns.match(sym->getName()))
1230 addSymbol(localSymbols, sym);
1231 };
1232 break;
1233 case SymtabPresence::SelectivelyExcluded:
1234 localSymbolsHandler = [&](Symbol *sym) {
1235 if (!config->localSymbolPatterns.match(sym->getName()))
1236 addSymbol(localSymbols, sym);
1237 };
1238 break;
1239 }
1240
1241 // Local symbols aren't in the SymbolTable, so we walk the list of object
1242 // files to gather them.
1243 // But if `-x` is set, then we don't need to. localSymbolsHandler() will do
1244 // the right thing regardless, but this check is a perf optimization because
1245 // iterating through all the input files and their symbols is expensive.
1246 if (config->localSymbolsPresence != SymtabPresence::None) {
1247 for (const InputFile *file : inputFiles) {
1248 if (auto *objFile = dyn_cast<ObjFile>(file)) {
1249 for (Symbol *sym : objFile->symbols) {
1250 if (auto *defined = dyn_cast_or_null<Defined>(sym)) {
1251 if (defined->isExternal() || !defined->isLive() ||
1252 !defined->includeInSymtab)
1253 continue;
1254 localSymbolsHandler(sym);
1255 }
1256 }
1257 }
1258 }
1259 }
1260
1261 // __dyld_private is a local symbol too. It's linker-created and doesn't
1262 // exist in any object file.
1263 if (in.stubHelper && in.stubHelper->dyldPrivate)
1264 localSymbolsHandler(in.stubHelper->dyldPrivate);
1265
1266 for (Symbol *sym : symtab->getSymbols()) {
1267 if (!sym->isLive())
1268 continue;
1269 if (auto *defined = dyn_cast<Defined>(sym)) {
1270 if (!defined->includeInSymtab)
1271 continue;
1272 assert(defined->isExternal())(static_cast <bool> (defined->isExternal()) ? void (
0) : __assert_fail ("defined->isExternal()", "lld/MachO/SyntheticSections.cpp"
, 1272, __extension__ __PRETTY_FUNCTION__))
;
1273 if (defined->privateExtern)
1274 localSymbolsHandler(defined);
1275 else
1276 addSymbol(externalSymbols, defined);
1277 } else if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
1278 if (dysym->isReferenced())
1279 addSymbol(undefinedSymbols, sym);
1280 }
1281 }
1282
1283 emitStabs();
1284 uint32_t symtabIndex = stabs.size();
1285 for (const SymtabEntry &entry :
1286 concat<SymtabEntry>(localSymbols, externalSymbols, undefinedSymbols)) {
1287 entry.sym->symtabIndex = symtabIndex++;
1288 }
1289}
1290
1291uint32_t SymtabSection::getNumSymbols() const {
1292 return stabs.size() + localSymbols.size() + externalSymbols.size() +
1293 undefinedSymbols.size();
1294}
1295
1296// This serves to hide (type-erase) the template parameter from SymtabSection.
1297template <class LP> class SymtabSectionImpl final : public SymtabSection {
1298public:
1299 SymtabSectionImpl(StringTableSection &stringTableSection)
1300 : SymtabSection(stringTableSection) {}
1301 uint64_t getRawSize() const override;
1302 void writeTo(uint8_t *buf) const override;
1303};
1304
1305template <class LP> uint64_t SymtabSectionImpl<LP>::getRawSize() const {
1306 return getNumSymbols() * sizeof(typename LP::nlist);
1307}
1308
1309template <class LP> void SymtabSectionImpl<LP>::writeTo(uint8_t *buf) const {
1310 auto *nList = reinterpret_cast<typename LP::nlist *>(buf);
1311 // Emit the stabs entries before the "real" symbols. We cannot emit them
1312 // after as that would render Symbol::symtabIndex inaccurate.
1313 for (const StabsEntry &entry : stabs) {
1314 nList->n_strx = entry.strx;
1315 nList->n_type = entry.type;
1316 nList->n_sect = entry.sect;
1317 nList->n_desc = entry.desc;
1318 nList->n_value = entry.value;
1319 ++nList;
1320 }
1321
1322 for (const SymtabEntry &entry : concat<const SymtabEntry>(
1323 localSymbols, externalSymbols, undefinedSymbols)) {
1324 nList->n_strx = entry.strx;
1325 // TODO populate n_desc with more flags
1326 if (auto *defined = dyn_cast<Defined>(entry.sym)) {
1327 uint8_t scope = 0;
1328 if (defined->privateExtern) {
1329 // Private external -- dylib scoped symbol.
1330 // Promote to non-external at link time.
1331 scope = N_PEXT;
1332 } else if (defined->isExternal()) {
1333 // Normal global symbol.
1334 scope = N_EXT;
1335 } else {
1336 // TU-local symbol from localSymbols.
1337 scope = 0;
1338 }
1339
1340 if (defined->isAbsolute()) {
1341 nList->n_type = scope | N_ABS;
1342 nList->n_sect = NO_SECT;
1343 nList->n_value = defined->value;
1344 } else {
1345 nList->n_type = scope | N_SECT;
1346 nList->n_sect = defined->isec->parent->index;
1347 // For the N_SECT symbol type, n_value is the address of the symbol
1348 nList->n_value = defined->getVA();
1349 }
1350 nList->n_desc |= defined->thumb ? N_ARM_THUMB_DEF : 0;
1351 nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
1352 nList->n_desc |=
1353 defined->referencedDynamically ? REFERENCED_DYNAMICALLY : 0;
1354 } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
1355 uint16_t n_desc = nList->n_desc;
1356 int16_t ordinal = ordinalForDylibSymbol(*dysym);
1357 if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
1358 SET_LIBRARY_ORDINAL(n_desc, DYNAMIC_LOOKUP_ORDINAL);
1359 else if (ordinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE)
1360 SET_LIBRARY_ORDINAL(n_desc, EXECUTABLE_ORDINAL);
1361 else {
1362 assert(ordinal > 0)(static_cast <bool> (ordinal > 0) ? void (0) : __assert_fail
("ordinal > 0", "lld/MachO/SyntheticSections.cpp", 1362, __extension__
__PRETTY_FUNCTION__))
;
1363 SET_LIBRARY_ORDINAL(n_desc, static_cast<uint8_t>(ordinal));
1364 }
1365
1366 nList->n_type = N_EXT;
1367 n_desc |= dysym->isWeakDef() ? N_WEAK_DEF : 0;
1368 n_desc |= dysym->isWeakRef() ? N_WEAK_REF : 0;
1369 nList->n_desc = n_desc;
1370 }
1371 ++nList;
1372 }
1373}
1374
1375template <class LP>
1376SymtabSection *
1377macho::makeSymtabSection(StringTableSection &stringTableSection) {
1378 return make<SymtabSectionImpl<LP>>(stringTableSection);
1379}
1380
1381IndirectSymtabSection::IndirectSymtabSection()
1382 : LinkEditSection(segment_names::linkEdit,
1383 section_names::indirectSymbolTable) {}
1384
1385uint32_t IndirectSymtabSection::getNumSymbols() const {
1386 uint32_t size = in.got->getEntries().size() +
1387 in.tlvPointers->getEntries().size() +
1388 in.stubs->getEntries().size();
1389 if (!config->emitChainedFixups)
1390 size += in.stubs->getEntries().size();
1391 return size;
1392}
1393
1394bool IndirectSymtabSection::isNeeded() const {
1395 return in.got->isNeeded() || in.tlvPointers->isNeeded() ||
1396 in.stubs->isNeeded();
1397}
1398
1399void IndirectSymtabSection::finalizeContents() {
1400 uint32_t off = 0;
1401 in.got->reserved1 = off;
1402 off += in.got->getEntries().size();
1403 in.tlvPointers->reserved1 = off;
1404 off += in.tlvPointers->getEntries().size();
1405 in.stubs->reserved1 = off;
1406 if (in.lazyPointers) {
1407 off += in.stubs->getEntries().size();
1408 in.lazyPointers->reserved1 = off;
1409 }
1410}
1411
1412static uint32_t indirectValue(const Symbol *sym) {
1413 if (sym->symtabIndex == UINT32_MAX(4294967295U))
1414 return INDIRECT_SYMBOL_LOCAL;
1415 if (auto *defined = dyn_cast<Defined>(sym))
1416 if (defined->privateExtern)
1417 return INDIRECT_SYMBOL_LOCAL;
1418 return sym->symtabIndex;
1419}
1420
1421void IndirectSymtabSection::writeTo(uint8_t *buf) const {
1422 uint32_t off = 0;
1423 for (const Symbol *sym : in.got->getEntries()) {
1424 write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
1425 ++off;
1426 }
1427 for (const Symbol *sym : in.tlvPointers->getEntries()) {
1428 write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
1429 ++off;
1430 }
1431 for (const Symbol *sym : in.stubs->getEntries()) {
1432 write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
1433 ++off;
1434 }
1435
1436 if (in.lazyPointers) {
1437 // There is a 1:1 correspondence between stubs and LazyPointerSection
1438 // entries. But giving __stubs and __la_symbol_ptr the same reserved1
1439 // (the offset into the indirect symbol table) so that they both refer
1440 // to the same range of offsets confuses `strip`, so write the stubs
1441 // symbol table offsets a second time.
1442 for (const Symbol *sym : in.stubs->getEntries()) {
1443 write32le(buf + off * sizeof(uint32_t), indirectValue(sym));
1444 ++off;
1445 }
1446 }
1447}
1448
1449StringTableSection::StringTableSection()
1450 : LinkEditSection(segment_names::linkEdit, section_names::stringTable) {}
1451
1452uint32_t StringTableSection::addString(StringRef str) {
1453 uint32_t strx = size;
1454 strings.push_back(str); // TODO: consider deduplicating strings
1455 size += str.size() + 1; // account for null terminator
1456 return strx;
1457}
1458
1459void StringTableSection::writeTo(uint8_t *buf) const {
1460 uint32_t off = 0;
1461 for (StringRef str : strings) {
1462 memcpy(buf + off, str.data(), str.size());
1463 off += str.size() + 1; // account for null terminator
1464 }
1465}
1466
1467static_assert((CodeSignatureSection::blobHeadersSize % 8) == 0);
1468static_assert((CodeSignatureSection::fixedHeadersSize % 8) == 0);
1469
1470CodeSignatureSection::CodeSignatureSection()
1471 : LinkEditSection(segment_names::linkEdit, section_names::codeSignature) {
1472 align = 16; // required by libstuff
1473 // FIXME: Consider using finalOutput instead of outputFile.
1474 fileName = config->outputFile;
1475 size_t slashIndex = fileName.rfind("/");
1476 if (slashIndex != std::string::npos)
1477 fileName = fileName.drop_front(slashIndex + 1);
1478
1479 // NOTE: Any changes to these calculations should be repeated
1480 // in llvm-objcopy's MachOLayoutBuilder::layoutTail.
1481 allHeadersSize = alignTo<16>(fixedHeadersSize + fileName.size() + 1);
1482 fileNamePad = allHeadersSize - fixedHeadersSize - fileName.size();
1483}
1484
1485uint32_t CodeSignatureSection::getBlockCount() const {
1486 return (fileOff + blockSize - 1) / blockSize;
1487}
1488
1489uint64_t CodeSignatureSection::getRawSize() const {
1490 return allHeadersSize + getBlockCount() * hashSize;
1491}
1492
1493void CodeSignatureSection::writeHashes(uint8_t *buf) const {
1494 // NOTE: Changes to this functionality should be repeated in llvm-objcopy's
1495 // MachOWriter::writeSignatureData.
1496 uint8_t *hashes = buf + fileOff + allHeadersSize;
1497 parallelFor(0, getBlockCount(), [&](size_t i) {
1498 sha256(buf + i * blockSize,
1499 std::min(static_cast<size_t>(fileOff - i * blockSize), blockSize),
1500 hashes + i * hashSize);
1501 });
1502#if defined(__APPLE__)
1503 // This is macOS-specific work-around and makes no sense for any
1504 // other host OS. See https://openradar.appspot.com/FB8914231
1505 //
1506 // The macOS kernel maintains a signature-verification cache to
1507 // quickly validate applications at time of execve(2). The trouble
1508 // is that for the kernel creates the cache entry at the time of the
1509 // mmap(2) call, before we have a chance to write either the code to
1510 // sign or the signature header+hashes. The fix is to invalidate
1511 // all cached data associated with the output file, thus discarding
1512 // the bogus prematurely-cached signature.
1513 msync(buf, fileOff + getSize(), MS_INVALIDATE);
1514#endif
1515}
1516
1517void CodeSignatureSection::writeTo(uint8_t *buf) const {
1518 // NOTE: Changes to this functionality should be repeated in llvm-objcopy's
1519 // MachOWriter::writeSignatureData.
1520 uint32_t signatureSize = static_cast<uint32_t>(getSize());
1521 auto *superBlob = reinterpret_cast<CS_SuperBlob *>(buf);
1522 write32be(&superBlob->magic, CSMAGIC_EMBEDDED_SIGNATURE);
1523 write32be(&superBlob->length, signatureSize);
1524 write32be(&superBlob->count, 1);
1525 auto *blobIndex = reinterpret_cast<CS_BlobIndex *>(&superBlob[1]);
1526 write32be(&blobIndex->type, CSSLOT_CODEDIRECTORY);
1527 write32be(&blobIndex->offset, blobHeadersSize);
1528 auto *codeDirectory =
1529 reinterpret_cast<CS_CodeDirectory *>(buf + blobHeadersSize);
1530 write32be(&codeDirectory->magic, CSMAGIC_CODEDIRECTORY);
1531 write32be(&codeDirectory->length, signatureSize - blobHeadersSize);
1532 write32be(&codeDirectory->version, CS_SUPPORTSEXECSEG);
1533 write32be(&codeDirectory->flags, CS_ADHOC | CS_LINKER_SIGNED);
1534 write32be(&codeDirectory->hashOffset,
1535 sizeof(CS_CodeDirectory) + fileName.size() + fileNamePad);
1536 write32be(&codeDirectory->identOffset, sizeof(CS_CodeDirectory));
1537 codeDirectory->nSpecialSlots = 0;
1538 write32be(&codeDirectory->nCodeSlots, getBlockCount());
1539 write32be(&codeDirectory->codeLimit, fileOff);
1540 codeDirectory->hashSize = static_cast<uint8_t>(hashSize);
1541 codeDirectory->hashType = kSecCodeSignatureHashSHA256;
1542 codeDirectory->platform = 0;
1543 codeDirectory->pageSize = blockSizeShift;
1544 codeDirectory->spare2 = 0;
1545 codeDirectory->scatterOffset = 0;
1546 codeDirectory->teamOffset = 0;
1547 codeDirectory->spare3 = 0;
1548 codeDirectory->codeLimit64 = 0;
1549 OutputSegment *textSeg = getOrCreateOutputSegment(segment_names::text);
1550 write64be(&codeDirectory->execSegBase, textSeg->fileOff);
1551 write64be(&codeDirectory->execSegLimit, textSeg->fileSize);
1552 write64be(&codeDirectory->execSegFlags,
1553 config->outputType == MH_EXECUTE ? CS_EXECSEG_MAIN_BINARY : 0);
1554 auto *id = reinterpret_cast<char *>(&codeDirectory[1]);
1555 memcpy(id, fileName.begin(), fileName.size());
1556 memset(id + fileName.size(), 0, fileNamePad);
1557}
1558
1559BitcodeBundleSection::BitcodeBundleSection()
1560 : SyntheticSection(segment_names::llvm, section_names::bitcodeBundle) {}
1561
1562class ErrorCodeWrapper {
1563public:
1564 explicit ErrorCodeWrapper(std::error_code ec) : errorCode(ec.value()) {}
1565 explicit ErrorCodeWrapper(int ec) : errorCode(ec) {}
1566 operator int() const { return errorCode; }
1567
1568private:
1569 int errorCode;
1570};
1571
1572#define CHECK_EC(exp)do { ErrorCodeWrapper ec(exp); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "exp"); } while (0);
\
1573 do { \
1574 ErrorCodeWrapper ec(exp); \
1575 if (ec) \
1576 fatal(Twine("operation failed with error code ") + Twine(ec) + ": " + \
1577 #exp); \
1578 } while (0);
1579
1580void BitcodeBundleSection::finalize() {
1581#ifdef LLVM_HAVE_LIBXAR
1582 using namespace llvm::sys::fs;
1583 CHECK_EC(createTemporaryFile("bitcode-bundle", "xar", xarPath))do { ErrorCodeWrapper ec(createTemporaryFile("bitcode-bundle"
, "xar", xarPath)); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "createTemporaryFile(\"bitcode-bundle\", \"xar\", xarPath)"
); } while (0);
;
1584
1585#pragma clang diagnostic push
1586#pragma clang diagnostic ignored "-Wdeprecated-declarations"
1587 xar_t xar(xar_open(xarPath.data(), O_RDWR));
1588#pragma clang diagnostic pop
1589 if (!xar)
1590 fatal("failed to open XAR temporary file at " + xarPath);
1591 CHECK_EC(xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE))do { ErrorCodeWrapper ec(xar_opt_set(xar, XAR_OPT_COMPRESSION
, XAR_OPT_VAL_NONE)); if (ec) fatal(Twine("operation failed with error code "
) + Twine(ec) + ": " + "xar_opt_set(xar, XAR_OPT_COMPRESSION, XAR_OPT_VAL_NONE)"
); } while (0);
;
1592 // FIXME: add more data to XAR
1593 CHECK_EC(xar_close(xar))do { ErrorCodeWrapper ec(xar_close(xar)); if (ec) fatal(Twine
("operation failed with error code ") + Twine(ec) + ": " + "xar_close(xar)"
); } while (0);
;
1594
1595 file_size(xarPath, xarSize);
1596#endif // defined(LLVM_HAVE_LIBXAR)
1597}
1598
1599void BitcodeBundleSection::writeTo(uint8_t *buf) const {
1600 using namespace llvm::sys::fs;
1601 file_t handle =
1602 CHECK(openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None),check2((openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None
)), [&] { return toString("failed to open XAR file"); })
1603 "failed to open XAR file")check2((openNativeFile(xarPath, CD_OpenExisting, FA_Read, OF_None
)), [&] { return toString("failed to open XAR file"); })
;
1604 std::error_code ec;
1605 mapped_file_region xarMap(handle, mapped_file_region::mapmode::readonly,
1606 xarSize, 0, ec);
1607 if (ec)
1608 fatal("failed to map XAR file");
1609 memcpy(buf, xarMap.const_data(), xarSize);
1610
1611 closeFile(handle);
1612 remove(xarPath);
1613}
1614
1615CStringSection::CStringSection(const char *name)
1616 : SyntheticSection(segment_names::text, name) {
1617 flags = S_CSTRING_LITERALS;
1618}
1619
1620void CStringSection::addInput(CStringInputSection *isec) {
1621 isec->parent = this;
1622 inputs.push_back(isec);
1623 if (isec->align > align)
1624 align = isec->align;
1625}
1626
1627void CStringSection::writeTo(uint8_t *buf) const {
1628 for (const CStringInputSection *isec : inputs) {
1629 for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
1630 if (!piece.live)
1631 continue;
1632 StringRef string = isec->getStringRef(i);
1633 memcpy(buf + piece.outSecOff, string.data(), string.size());
1634 }
1635 }
1636}
1637
1638void CStringSection::finalizeContents() {
1639 uint64_t offset = 0;
1640 for (CStringInputSection *isec : inputs) {
1641 for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
1642 if (!piece.live)
1643 continue;
1644 // See comment above DeduplicatedCStringSection for how alignment is
1645 // handled.
1646 uint32_t pieceAlign = 1
1647 << llvm::countr_zero(isec->align | piece.inSecOff);
1648 offset = alignToPowerOf2(offset, pieceAlign);
1649 piece.outSecOff = offset;
1650 isec->isFinal = true;
1651 StringRef string = isec->getStringRef(i);
1652 offset += string.size() + 1; // account for null terminator
1653 }
1654 }
1655 size = offset;
1656}
1657
1658// Mergeable cstring literals are found under the __TEXT,__cstring section. In
1659// contrast to ELF, which puts strings that need different alignments into
1660// different sections, clang's Mach-O backend puts them all in one section.
1661// Strings that need to be aligned have the .p2align directive emitted before
1662// them, which simply translates into zero padding in the object file. In other
1663// words, we have to infer the desired alignment of these cstrings from their
1664// addresses.
1665//
1666// We differ slightly from ld64 in how we've chosen to align these cstrings.
1667// Both LLD and ld64 preserve the number of trailing zeros in each cstring's
1668// address in the input object files. When deduplicating identical cstrings,
1669// both linkers pick the cstring whose address has more trailing zeros, and
1670// preserve the alignment of that address in the final binary. However, ld64
1671// goes a step further and also preserves the offset of the cstring from the
1672// last section-aligned address. I.e. if a cstring is at offset 18 in the
1673// input, with a section alignment of 16, then both LLD and ld64 will ensure the
1674// final address is 2-byte aligned (since 18 == 16 + 2). But ld64 will also
1675// ensure that the final address is of the form 16 * k + 2 for some k.
1676//
1677// Note that ld64's heuristic means that a dedup'ed cstring's final address is
1678// dependent on the order of the input object files. E.g. if in addition to the
1679// cstring at offset 18 above, we have a duplicate one in another file with a
1680// `.cstring` section alignment of 2 and an offset of zero, then ld64 will pick
1681// the cstring from the object file earlier on the command line (since both have
1682// the same number of trailing zeros in their address). So the final cstring may
1683// either be at some address `16 * k + 2` or at some address `2 * k`.
1684//
1685// I've opted not to follow this behavior primarily for implementation
1686// simplicity, and secondarily to save a few more bytes. It's not clear to me
1687// that preserving the section alignment + offset is ever necessary, and there
1688// are many cases that are clearly redundant. In particular, if an x86_64 object
1689// file contains some strings that are accessed via SIMD instructions, then the
1690// .cstring section in the object file will be 16-byte-aligned (since SIMD
1691// requires its operand addresses to be 16-byte aligned). However, there will
1692// typically also be other cstrings in the same file that aren't used via SIMD
1693// and don't need this alignment. They will be emitted at some arbitrary address
1694// `A`, but ld64 will treat them as being 16-byte aligned with an offset of `16
1695// % A`.
1696void DeduplicatedCStringSection::finalizeContents() {
1697 // Find the largest alignment required for each string.
1698 for (const CStringInputSection *isec : inputs) {
1699 for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
1700 if (!piece.live)
1701 continue;
1702 auto s = isec->getCachedHashStringRef(i);
1703 assert(isec->align != 0)(static_cast <bool> (isec->align != 0) ? void (0) : __assert_fail
("isec->align != 0", "lld/MachO/SyntheticSections.cpp", 1703
, __extension__ __PRETTY_FUNCTION__))
;
1704 uint8_t trailingZeros = llvm::countr_zero(isec->align | piece.inSecOff);
1705 auto it = stringOffsetMap.insert(
1706 std::make_pair(s, StringOffset(trailingZeros)));
1707 if (!it.second && it.first->second.trailingZeros < trailingZeros)
1708 it.first->second.trailingZeros = trailingZeros;
1709 }
1710 }
1711
1712 // Assign an offset for each string and save it to the corresponding
1713 // StringPieces for easy access.
1714 for (CStringInputSection *isec : inputs) {
1715 for (const auto &[i, piece] : llvm::enumerate(isec->pieces)) {
1716 if (!piece.live)
1717 continue;
1718 auto s = isec->getCachedHashStringRef(i);
1719 auto it = stringOffsetMap.find(s);
1720 assert(it != stringOffsetMap.end())(static_cast <bool> (it != stringOffsetMap.end()) ? void
(0) : __assert_fail ("it != stringOffsetMap.end()", "lld/MachO/SyntheticSections.cpp"
, 1720, __extension__ __PRETTY_FUNCTION__))
;
1721 StringOffset &offsetInfo = it->second;
1722 if (offsetInfo.outSecOff == UINT64_MAX(18446744073709551615UL)) {
1723 offsetInfo.outSecOff =
1724 alignToPowerOf2(size, 1ULL << offsetInfo.trailingZeros);
1725 size =
1726 offsetInfo.outSecOff + s.size() + 1; // account for null terminator
1727 }
1728 piece.outSecOff = offsetInfo.outSecOff;
1729 }
1730 isec->isFinal = true;
1731 }
1732}
1733
1734void DeduplicatedCStringSection::writeTo(uint8_t *buf) const {
1735 for (const auto &p : stringOffsetMap) {
1736 StringRef data = p.first.val();
1737 uint64_t off = p.second.outSecOff;
1738 if (!data.empty())
1739 memcpy(buf + off, data.data(), data.size());
1740 }
1741}
1742
1743DeduplicatedCStringSection::StringOffset
1744DeduplicatedCStringSection::getStringOffset(StringRef str) const {
1745 // StringPiece uses 31 bits to store the hashes, so we replicate that
1746 uint32_t hash = xxHash64(str) & 0x7fffffff;
1747 auto offset = stringOffsetMap.find(CachedHashStringRef(str, hash));
1748 assert(offset != stringOffsetMap.end() &&(static_cast <bool> (offset != stringOffsetMap.end() &&
"Looked-up strings should always exist in section") ? void (
0) : __assert_fail ("offset != stringOffsetMap.end() && \"Looked-up strings should always exist in section\""
, "lld/MachO/SyntheticSections.cpp", 1749, __extension__ __PRETTY_FUNCTION__
))
1749 "Looked-up strings should always exist in section")(static_cast <bool> (offset != stringOffsetMap.end() &&
"Looked-up strings should always exist in section") ? void (
0) : __assert_fail ("offset != stringOffsetMap.end() && \"Looked-up strings should always exist in section\""
, "lld/MachO/SyntheticSections.cpp", 1749, __extension__ __PRETTY_FUNCTION__
))
;
1750 return offset->second;
1751}
1752
1753// This section is actually emitted as __TEXT,__const by ld64, but clang may
1754// emit input sections of that name, and LLD doesn't currently support mixing
1755// synthetic and concat-type OutputSections. To work around this, I've given
1756// our merged-literals section a different name.
1757WordLiteralSection::WordLiteralSection()
1758 : SyntheticSection(segment_names::text, section_names::literals) {
1759 align = 16;
1760}
1761
1762void WordLiteralSection::addInput(WordLiteralInputSection *isec) {
1763 isec->parent = this;
1764 inputs.push_back(isec);
1765}
1766
1767void WordLiteralSection::finalizeContents() {
1768 for (WordLiteralInputSection *isec : inputs) {
1769 // We do all processing of the InputSection here, so it will be effectively
1770 // finalized.
1771 isec->isFinal = true;
1772 const uint8_t *buf = isec->data.data();
1773 switch (sectionType(isec->getFlags())) {
1774 case S_4BYTE_LITERALS: {
1775 for (size_t off = 0, e = isec->data.size(); off < e; off += 4) {
1776 if (!isec->isLive(off))
1777 continue;
1778 uint32_t value = *reinterpret_cast<const uint32_t *>(buf + off);
1779 literal4Map.emplace(value, literal4Map.size());
1780 }
1781 break;
1782 }
1783 case S_8BYTE_LITERALS: {
1784 for (size_t off = 0, e = isec->data.size(); off < e; off += 8) {
1785 if (!isec->isLive(off))
1786 continue;
1787 uint64_t value = *reinterpret_cast<const uint64_t *>(buf + off);
1788 literal8Map.emplace(value, literal8Map.size());
1789 }
1790 break;
1791 }
1792 case S_16BYTE_LITERALS: {
1793 for (size_t off = 0, e = isec->data.size(); off < e; off += 16) {
1794 if (!isec->isLive(off))
1795 continue;
1796 UInt128 value = *reinterpret_cast<const UInt128 *>(buf + off);
1797 literal16Map.emplace(value, literal16Map.size());
1798 }
1799 break;
1800 }
1801 default:
1802 llvm_unreachable("invalid literal section type")::llvm::llvm_unreachable_internal("invalid literal section type"
, "lld/MachO/SyntheticSections.cpp", 1802)
;
1803 }
1804 }
1805}
1806
1807void WordLiteralSection::writeTo(uint8_t *buf) const {
1808 // Note that we don't attempt to do any endianness conversion in addInput(),
1809 // so we don't do it here either -- just write out the original value,
1810 // byte-for-byte.
1811 for (const auto &p : literal16Map)
1812 memcpy(buf + p.second * 16, &p.first, 16);
1813 buf += literal16Map.size() * 16;
1814
1815 for (const auto &p : literal8Map)
1816 memcpy(buf + p.second * 8, &p.first, 8);
1817 buf += literal8Map.size() * 8;
1818
1819 for (const auto &p : literal4Map)
1820 memcpy(buf + p.second * 4, &p.first, 4);
1821}
1822
1823ObjCImageInfoSection::ObjCImageInfoSection()
1824 : SyntheticSection(segment_names::data, section_names::objCImageInfo) {}
1825
1826ObjCImageInfoSection::ImageInfo
1827ObjCImageInfoSection::parseImageInfo(const InputFile *file) {
1828 ImageInfo info;
1829 ArrayRef<uint8_t> data = file->objCImageInfo;
1830 // The image info struct has the following layout:
1831 // struct {
1832 // uint32_t version;
1833 // uint32_t flags;
1834 // };
1835 if (data.size() < 8) {
1836 warn(toString(file) + ": invalid __objc_imageinfo size");
1837 return info;
1838 }
1839
1840 auto *buf = reinterpret_cast<const uint32_t *>(data.data());
1841 if (read32le(buf) != 0) {
1842 warn(toString(file) + ": invalid __objc_imageinfo version");
1843 return info;
1844 }
1845
1846 uint32_t flags = read32le(buf + 1);
1847 info.swiftVersion = (flags >> 8) & 0xff;
1848 info.hasCategoryClassProperties = flags & 0x40;
1849 return info;
1850}
1851
1852static std::string swiftVersionString(uint8_t version) {
1853 switch (version) {
1854 case 1:
1855 return "1.0";
1856 case 2:
1857 return "1.1";
1858 case 3:
1859 return "2.0";
1860 case 4:
1861 return "3.0";
1862 case 5:
1863 return "4.0";
1864 default:
1865 return ("0x" + Twine::utohexstr(version)).str();
1866 }
1867}
1868
1869// Validate each object file's __objc_imageinfo and use them to generate the
1870// image info for the output binary. Only two pieces of info are relevant:
1871// 1. The Swift version (should be identical across inputs)
1872// 2. `bool hasCategoryClassProperties` (true only if true for all inputs)
1873void ObjCImageInfoSection::finalizeContents() {
1874 assert(files.size() != 0)(static_cast <bool> (files.size() != 0) ? void (0) : __assert_fail
("files.size() != 0", "lld/MachO/SyntheticSections.cpp", 1874
, __extension__ __PRETTY_FUNCTION__))
; // should have already been checked via isNeeded()
1
Assuming the condition is true
2
'?' condition is true
1875
1876 info.hasCategoryClassProperties = true;
1877 const InputFile *firstFile;
3
'firstFile' declared without an initial value
1878 for (const InputFile *file : files) {
1879 ImageInfo inputInfo = parseImageInfo(file);
1880 info.hasCategoryClassProperties &= inputInfo.hasCategoryClassProperties;
1881
1882 // swiftVersion 0 means no Swift is present, so no version checking required
1883 if (inputInfo.swiftVersion == 0)
4
Assuming field 'swiftVersion' is not equal to 0
1884 continue;
1885
1886 if (info.swiftVersion != 0 && info.swiftVersion != inputInfo.swiftVersion) {
5
Assuming field 'swiftVersion' is not equal to 0
6
Assuming 'info.swiftVersion' is not equal to 'inputInfo.swiftVersion'
7
Taking true branch
1887 error("Swift version mismatch: " + toString(firstFile) + " has version " +
8
1st function call argument is an uninitialized value
1888 swiftVersionString(info.swiftVersion) + " but " + toString(file) +
1889 " has version " + swiftVersionString(inputInfo.swiftVersion));
1890 } else {
1891 info.swiftVersion = inputInfo.swiftVersion;
1892 firstFile = file;
1893 }
1894 }
1895}
1896
1897void ObjCImageInfoSection::writeTo(uint8_t *buf) const {
1898 uint32_t flags = info.hasCategoryClassProperties ? 0x40 : 0x0;
1899 flags |= info.swiftVersion << 8;
1900 write32le(buf + 4, flags);
1901}
1902
1903InitOffsetsSection::InitOffsetsSection()
1904 : SyntheticSection(segment_names::text, section_names::initOffsets) {
1905 flags = S_INIT_FUNC_OFFSETS;
1906 align = 4; // This section contains 32-bit integers.
1907}
1908
1909uint64_t InitOffsetsSection::getSize() const {
1910 size_t count = 0;
1911 for (const ConcatInputSection *isec : sections)
1912 count += isec->relocs.size();
1913 return count * sizeof(uint32_t);
1914}
1915
1916void InitOffsetsSection::writeTo(uint8_t *buf) const {
1917 // FIXME: Add function specified by -init when that argument is implemented.
1918 for (ConcatInputSection *isec : sections) {
1919 for (const Reloc &rel : isec->relocs) {
1920 const Symbol *referent = rel.referent.dyn_cast<Symbol *>();
1921 assert(referent && "section relocation should have been rejected")(static_cast <bool> (referent && "section relocation should have been rejected"
) ? void (0) : __assert_fail ("referent && \"section relocation should have been rejected\""
, "lld/MachO/SyntheticSections.cpp", 1921, __extension__ __PRETTY_FUNCTION__
))
;
1922 uint64_t offset = referent->getVA() - in.header->addr;
1923 // FIXME: Can we handle this gracefully?
1924 if (offset > UINT32_MAX(4294967295U))
1925 fatal(isec->getLocation(rel.offset) + ": offset to initializer " +
1926 referent->getName() + " (" + utohexstr(offset) +
1927 ") does not fit in 32 bits");
1928
1929 // Entries need to be added in the order they appear in the section, but
1930 // relocations aren't guaranteed to be sorted.
1931 size_t index = rel.offset >> target->p2WordSize;
1932 write32le(&buf[index * sizeof(uint32_t)], offset);
1933 }
1934 buf += isec->relocs.size() * sizeof(uint32_t);
1935 }
1936}
1937
1938// The inputs are __mod_init_func sections, which contain pointers to
1939// initializer functions, therefore all relocations should be of the UNSIGNED
1940// type. InitOffsetsSection stores offsets, so if the initializer's address is
1941// not known at link time, stub-indirection has to be used.
1942void InitOffsetsSection::setUp() {
1943 for (const ConcatInputSection *isec : sections) {
1944 for (const Reloc &rel : isec->relocs) {
1945 RelocAttrs attrs = target->getRelocAttrs(rel.type);
1946 if (!attrs.hasAttr(RelocAttrBits::UNSIGNED))
1947 error(isec->getLocation(rel.offset) +
1948 ": unsupported relocation type: " + attrs.name);
1949 if (rel.addend != 0)
1950 error(isec->getLocation(rel.offset) +
1951 ": relocation addend is not representable in __init_offsets");
1952 if (rel.referent.is<InputSection *>())
1953 error(isec->getLocation(rel.offset) +
1954 ": unexpected section relocation");
1955
1956 Symbol *sym = rel.referent.dyn_cast<Symbol *>();
1957 if (auto *undefined = dyn_cast<Undefined>(sym))
1958 treatUndefinedSymbol(*undefined, isec, rel.offset);
1959 if (needsBinding(sym))
1960 in.stubs->addEntry(sym);
1961 }
1962 }
1963}
1964
1965void macho::createSyntheticSymbols() {
1966 auto addHeaderSymbol = [](const char *name) {
1967 symtab->addSynthetic(name, in.header->isec, /*value=*/0,
1968 /*isPrivateExtern=*/true, /*includeInSymtab=*/false,
1969 /*referencedDynamically=*/false);
1970 };
1971
1972 switch (config->outputType) {
1973 // FIXME: Assign the right address value for these symbols
1974 // (rather than 0). But we need to do that after assignAddresses().
1975 case MH_EXECUTE:
1976 // If linking PIE, __mh_execute_header is a defined symbol in
1977 // __TEXT, __text)
1978 // Otherwise, it's an absolute symbol.
1979 if (config->isPic)
1980 symtab->addSynthetic("__mh_execute_header", in.header->isec, /*value=*/0,
1981 /*isPrivateExtern=*/false, /*includeInSymtab=*/true,
1982 /*referencedDynamically=*/true);
1983 else
1984 symtab->addSynthetic("__mh_execute_header", /*isec=*/nullptr, /*value=*/0,
1985 /*isPrivateExtern=*/false, /*includeInSymtab=*/true,
1986 /*referencedDynamically=*/true);
1987 break;
1988
1989 // The following symbols are N_SECT symbols, even though the header is not
1990 // part of any section and that they are private to the bundle/dylib/object
1991 // they are part of.
1992 case MH_BUNDLE:
1993 addHeaderSymbol("__mh_bundle_header");
1994 break;
1995 case MH_DYLIB:
1996 addHeaderSymbol("__mh_dylib_header");
1997 break;
1998 case MH_DYLINKER:
1999 addHeaderSymbol("__mh_dylinker_header");
2000 break;
2001 case MH_OBJECT:
2002 addHeaderSymbol("__mh_object_header");
2003 break;
2004 default:
2005 llvm_unreachable("unexpected outputType")::llvm::llvm_unreachable_internal("unexpected outputType", "lld/MachO/SyntheticSections.cpp"
, 2005)
;
2006 break;
2007 }
2008
2009 // The Itanium C++ ABI requires dylibs to pass a pointer to __cxa_atexit
2010 // which does e.g. cleanup of static global variables. The ABI document
2011 // says that the pointer can point to any address in one of the dylib's
2012 // segments, but in practice ld64 seems to set it to point to the header,
2013 // so that's what's implemented here.
2014 addHeaderSymbol("___dso_handle");
2015}
2016
2017ChainedFixupsSection::ChainedFixupsSection()
2018 : LinkEditSection(segment_names::linkEdit, section_names::chainFixups) {}
2019
2020bool ChainedFixupsSection::isNeeded() const {
2021 assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
(0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 2021, __extension__ __PRETTY_FUNCTION__))
;
2022 // dyld always expects LC_DYLD_CHAINED_FIXUPS to point to a valid
2023 // dyld_chained_fixups_header, so we create this section even if there aren't
2024 // any fixups.
2025 return true;
2026}
2027
2028static bool needsWeakBind(const Symbol &sym) {
2029 if (auto *dysym = dyn_cast<DylibSymbol>(&sym))
2030 return dysym->isWeakDef();
2031 if (auto *defined = dyn_cast<Defined>(&sym))
2032 return defined->isExternalWeakDef();
2033 return false;
2034}
2035
2036void ChainedFixupsSection::addBinding(const Symbol *sym,
2037 const InputSection *isec, uint64_t offset,
2038 int64_t addend) {
2039 locations.emplace_back(isec, offset);
2040 int64_t outlineAddend = (addend < 0 || addend > 0xFF) ? addend : 0;
2041 auto [it, inserted] = bindings.insert(
2042 {{sym, outlineAddend}, static_cast<uint32_t>(bindings.size())});
2043
2044 if (inserted) {
2045 symtabSize += sym->getName().size() + 1;
2046 hasWeakBind = hasWeakBind || needsWeakBind(*sym);
2047 if (!isInt<23>(outlineAddend))
2048 needsLargeAddend = true;
2049 else if (outlineAddend != 0)
2050 needsAddend = true;
2051 }
2052}
2053
2054std::pair<uint32_t, uint8_t>
2055ChainedFixupsSection::getBinding(const Symbol *sym, int64_t addend) const {
2056 int64_t outlineAddend = (addend < 0 || addend > 0xFF) ? addend : 0;
2057 auto it = bindings.find({sym, outlineAddend});
2058 assert(it != bindings.end() && "binding not found in the imports table")(static_cast <bool> (it != bindings.end() && "binding not found in the imports table"
) ? void (0) : __assert_fail ("it != bindings.end() && \"binding not found in the imports table\""
, "lld/MachO/SyntheticSections.cpp", 2058, __extension__ __PRETTY_FUNCTION__
))
;
2059 if (outlineAddend == 0)
2060 return {it->second, addend};
2061 return {it->second, 0};
2062}
2063
2064static size_t writeImport(uint8_t *buf, int format, uint32_t libOrdinal,
2065 bool weakRef, uint32_t nameOffset, int64_t addend) {
2066 switch (format) {
2067 case DYLD_CHAINED_IMPORT: {
2068 auto *import = reinterpret_cast<dyld_chained_import *>(buf);
2069 import->lib_ordinal = libOrdinal;
2070 import->weak_import = weakRef;
2071 import->name_offset = nameOffset;
2072 return sizeof(dyld_chained_import);
2073 }
2074 case DYLD_CHAINED_IMPORT_ADDEND: {
2075 auto *import = reinterpret_cast<dyld_chained_import_addend *>(buf);
2076 import->lib_ordinal = libOrdinal;
2077 import->weak_import = weakRef;
2078 import->name_offset = nameOffset;
2079 import->addend = addend;
2080 return sizeof(dyld_chained_import_addend);
2081 }
2082 case DYLD_CHAINED_IMPORT_ADDEND64: {
2083 auto *import = reinterpret_cast<dyld_chained_import_addend64 *>(buf);
2084 import->lib_ordinal = libOrdinal;
2085 import->weak_import = weakRef;
2086 import->name_offset = nameOffset;
2087 import->addend = addend;
2088 return sizeof(dyld_chained_import_addend64);
2089 }
2090 default:
2091 llvm_unreachable("Unknown import format")::llvm::llvm_unreachable_internal("Unknown import format", "lld/MachO/SyntheticSections.cpp"
, 2091)
;
2092 }
2093}
2094
2095size_t ChainedFixupsSection::SegmentInfo::getSize() const {
2096 assert(pageStarts.size() > 0 && "SegmentInfo for segment with no fixups?")(static_cast <bool> (pageStarts.size() > 0 &&
"SegmentInfo for segment with no fixups?") ? void (0) : __assert_fail
("pageStarts.size() > 0 && \"SegmentInfo for segment with no fixups?\""
, "lld/MachO/SyntheticSections.cpp", 2096, __extension__ __PRETTY_FUNCTION__
))
;
2097 return alignTo<8>(sizeof(dyld_chained_starts_in_segment) +
2098 pageStarts.back().first * sizeof(uint16_t));
2099}
2100
2101size_t ChainedFixupsSection::SegmentInfo::writeTo(uint8_t *buf) const {
2102 auto *segInfo = reinterpret_cast<dyld_chained_starts_in_segment *>(buf);
2103 segInfo->size = getSize();
2104 segInfo->page_size = target->getPageSize();
2105 // FIXME: Use DYLD_CHAINED_PTR_64_OFFSET on newer OS versions.
2106 segInfo->pointer_format = DYLD_CHAINED_PTR_64;
2107 segInfo->segment_offset = oseg->addr - in.header->addr;
2108 segInfo->max_valid_pointer = 0; // not used on 64-bit
2109 segInfo->page_count = pageStarts.back().first + 1;
2110
2111 uint16_t *starts = segInfo->page_start;
2112 for (size_t i = 0; i < segInfo->page_count; ++i)
2113 starts[i] = DYLD_CHAINED_PTR_START_NONE;
2114
2115 for (auto [pageIdx, startAddr] : pageStarts)
2116 starts[pageIdx] = startAddr;
2117 return segInfo->size;
2118}
2119
2120static size_t importEntrySize(int format) {
2121 switch (format) {
2122 case DYLD_CHAINED_IMPORT:
2123 return sizeof(dyld_chained_import);
2124 case DYLD_CHAINED_IMPORT_ADDEND:
2125 return sizeof(dyld_chained_import_addend);
2126 case DYLD_CHAINED_IMPORT_ADDEND64:
2127 return sizeof(dyld_chained_import_addend64);
2128 default:
2129 llvm_unreachable("Unknown import format")::llvm::llvm_unreachable_internal("Unknown import format", "lld/MachO/SyntheticSections.cpp"
, 2129)
;
2130 }
2131}
2132
2133// This is step 3 of the algorithm described in the class comment of
2134// ChainedFixupsSection.
2135//
2136// LC_DYLD_CHAINED_FIXUPS data consists of (in this order):
2137// * A dyld_chained_fixups_header
2138// * A dyld_chained_starts_in_image
2139// * One dyld_chained_starts_in_segment per segment
2140// * List of all imports (dyld_chained_import, dyld_chained_import_addend, or
2141// dyld_chained_import_addend64)
2142// * Names of imported symbols
2143void ChainedFixupsSection::writeTo(uint8_t *buf) const {
2144 auto *header = reinterpret_cast<dyld_chained_fixups_header *>(buf);
2145 header->fixups_version = 0;
2146 header->imports_count = bindings.size();
2147 header->imports_format = importFormat;
2148 header->symbols_format = 0;
2149
2150 buf += alignTo<8>(sizeof(*header));
2151
2152 auto curOffset = [&buf, &header]() -> uint32_t {
2153 return buf - reinterpret_cast<uint8_t *>(header);
2154 };
2155
2156 header->starts_offset = curOffset();
2157
2158 auto *imageInfo = reinterpret_cast<dyld_chained_starts_in_image *>(buf);
2159 imageInfo->seg_count = outputSegments.size();
2160 uint32_t *segStarts = imageInfo->seg_info_offset;
2161
2162 // dyld_chained_starts_in_image ends in a flexible array member containing an
2163 // uint32_t for each segment. Leave room for it, and fill it via segStarts.
2164 buf += alignTo<8>(offsetof(dyld_chained_starts_in_image, seg_info_offset)__builtin_offsetof(dyld_chained_starts_in_image, seg_info_offset
)
+
2165 outputSegments.size() * sizeof(uint32_t));
2166
2167 // Initialize all offsets to 0, which indicates that the segment does not have
2168 // fixups. Those that do have them will be filled in below.
2169 for (size_t i = 0; i < outputSegments.size(); ++i)
2170 segStarts[i] = 0;
2171
2172 for (const SegmentInfo &seg : fixupSegments) {
2173 segStarts[seg.oseg->index] = curOffset() - header->starts_offset;
2174 buf += seg.writeTo(buf);
2175 }
2176
2177 // Write imports table.
2178 header->imports_offset = curOffset();
2179 uint64_t nameOffset = 0;
2180 for (auto [import, idx] : bindings) {
2181 const Symbol &sym = *import.first;
2182 int16_t libOrdinal = needsWeakBind(sym)
2183 ? (int64_t)BIND_SPECIAL_DYLIB_WEAK_LOOKUP
2184 : ordinalForSymbol(sym);
2185 buf += writeImport(buf, importFormat, libOrdinal, sym.isWeakRef(),
2186 nameOffset, import.second);
2187 nameOffset += sym.getName().size() + 1;
2188 }
2189
2190 // Write imported symbol names.
2191 header->symbols_offset = curOffset();
2192 for (auto [import, idx] : bindings) {
2193 StringRef name = import.first->getName();
2194 memcpy(buf, name.data(), name.size());
2195 buf += name.size() + 1; // account for null terminator
2196 }
2197
2198 assert(curOffset() == getRawSize())(static_cast <bool> (curOffset() == getRawSize()) ? void
(0) : __assert_fail ("curOffset() == getRawSize()", "lld/MachO/SyntheticSections.cpp"
, 2198, __extension__ __PRETTY_FUNCTION__))
;
2199}
2200
2201// This is step 2 of the algorithm described in the class comment of
2202// ChainedFixupsSection.
2203void ChainedFixupsSection::finalizeContents() {
2204 assert(target->wordSize == 8 && "Only 64-bit platforms are supported")(static_cast <bool> (target->wordSize == 8 &&
"Only 64-bit platforms are supported") ? void (0) : __assert_fail
("target->wordSize == 8 && \"Only 64-bit platforms are supported\""
, "lld/MachO/SyntheticSections.cpp", 2204, __extension__ __PRETTY_FUNCTION__
))
;
2205 assert(config->emitChainedFixups)(static_cast <bool> (config->emitChainedFixups) ? void
(0) : __assert_fail ("config->emitChainedFixups", "lld/MachO/SyntheticSections.cpp"
, 2205, __extension__ __PRETTY_FUNCTION__))
;
2206
2207 if (!isUInt<32>(symtabSize))
2208 error("cannot encode chained fixups: imported symbols table size " +
2209 Twine(symtabSize) + " exceeds 4 GiB");
2210
2211 if (needsLargeAddend || !isUInt<23>(symtabSize))
2212 importFormat = DYLD_CHAINED_IMPORT_ADDEND64;
2213 else if (needsAddend)
2214 importFormat = DYLD_CHAINED_IMPORT_ADDEND;
2215 else
2216 importFormat = DYLD_CHAINED_IMPORT;
2217
2218 for (Location &loc : locations)
2219 loc.offset =
2220 loc.isec->parent->getSegmentOffset() + loc.isec->getOffset(loc.offset);
2221
2222 llvm::sort(locations, [](const Location &a, const Location &b) {
2223 const OutputSegment *segA = a.isec->parent->parent;
2224 const OutputSegment *segB = b.isec->parent->parent;
2225 if (segA == segB)
2226 return a.offset < b.offset;
2227 return segA->addr < segB->addr;
2228 });
2229
2230 auto sameSegment = [](const Location &a, const Location &b) {
2231 return a.isec->parent->parent == b.isec->parent->parent;
2232 };
2233
2234 const uint64_t pageSize = target->getPageSize();
2235 for (size_t i = 0, count = locations.size(); i < count;) {
2236 const Location &firstLoc = locations[i];
2237 fixupSegments.emplace_back(firstLoc.isec->parent->parent);
2238 while (i < count && sameSegment(locations[i], firstLoc)) {
2239 uint32_t pageIdx = locations[i].offset / pageSize;
2240 fixupSegments.back().pageStarts.emplace_back(
2241 pageIdx, locations[i].offset % pageSize);
2242 ++i;
2243 while (i < count && sameSegment(locations[i], firstLoc) &&
2244 locations[i].offset / pageSize == pageIdx)
2245 ++i;
2246 }
2247 }
2248
2249 // Compute expected encoded size.
2250 size = alignTo<8>(sizeof(dyld_chained_fixups_header));
2251 size += alignTo<8>(offsetof(dyld_chained_starts_in_image, seg_info_offset)__builtin_offsetof(dyld_chained_starts_in_image, seg_info_offset
)
+
2252 outputSegments.size() * sizeof(uint32_t));
2253 for (const SegmentInfo &seg : fixupSegments)
2254 size += seg.getSize();
2255 size += importEntrySize(importFormat) * bindings.size();
2256 size += symtabSize;
2257}
2258
2259template SymtabSection *macho::makeSymtabSection<LP64>(StringTableSection &);
2260template SymtabSection *macho::makeSymtabSection<ILP32>(StringTableSection &);