|
173
|
1 //===- Writer.cpp ---------------------------------------------------------===//
|
|
|
2 //
|
|
|
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
4 // See https://llvm.org/LICENSE.txt for license information.
|
|
|
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
6 //
|
|
|
7 //===----------------------------------------------------------------------===//
|
|
|
8
|
|
|
9 #include "Writer.h"
|
|
207
|
10 #include "ConcatOutputSection.h"
|
|
173
|
11 #include "Config.h"
|
|
|
12 #include "InputFiles.h"
|
|
|
13 #include "InputSection.h"
|
|
207
|
14 #include "MapFile.h"
|
|
173
|
15 #include "OutputSection.h"
|
|
|
16 #include "OutputSegment.h"
|
|
|
17 #include "SymbolTable.h"
|
|
|
18 #include "Symbols.h"
|
|
|
19 #include "SyntheticSections.h"
|
|
|
20 #include "Target.h"
|
|
207
|
21 #include "UnwindInfoSection.h"
|
|
173
|
22
|
|
207
|
23 #include "lld/Common/Arrays.h"
|
|
173
|
24 #include "lld/Common/ErrorHandler.h"
|
|
|
25 #include "lld/Common/Memory.h"
|
|
|
26 #include "llvm/BinaryFormat/MachO.h"
|
|
207
|
27 #include "llvm/Config/llvm-config.h"
|
|
173
|
28 #include "llvm/Support/LEB128.h"
|
|
|
29 #include "llvm/Support/MathExtras.h"
|
|
207
|
30 #include "llvm/Support/Parallel.h"
|
|
173
|
31 #include "llvm/Support/Path.h"
|
|
207
|
32 #include "llvm/Support/TimeProfiler.h"
|
|
|
33 #include "llvm/Support/xxhash.h"
|
|
|
34
|
|
|
35 #include <algorithm>
|
|
173
|
36
|
|
|
37 using namespace llvm;
|
|
|
38 using namespace llvm::MachO;
|
|
207
|
39 using namespace llvm::sys;
|
|
173
|
40 using namespace lld;
|
|
|
41 using namespace lld::macho;
|
|
|
42
|
|
|
43 namespace {
|
|
207
|
44 class LCUuid;
|
|
173
|
45
|
|
|
46 class Writer {
|
|
|
47 public:
|
|
|
48 Writer() : buffer(errorHandler().outputBuffer) {}
|
|
|
49
|
|
|
50 void scanRelocations();
|
|
207
|
51 void scanSymbols();
|
|
|
52 template <class LP> void createOutputSections();
|
|
|
53 template <class LP> void createLoadCommands();
|
|
|
54 void finalizeAddresses();
|
|
|
55 void finalizeLinkEditSegment();
|
|
173
|
56 void assignAddresses(OutputSegment *);
|
|
|
57
|
|
|
58 void openFile();
|
|
|
59 void writeSections();
|
|
207
|
60 void writeUuid();
|
|
|
61 void writeCodeSignature();
|
|
|
62 void writeOutputFile();
|
|
173
|
63
|
|
207
|
64 template <class LP> void run();
|
|
173
|
65
|
|
|
66 std::unique_ptr<FileOutputBuffer> &buffer;
|
|
|
67 uint64_t addr = 0;
|
|
|
68 uint64_t fileOff = 0;
|
|
207
|
69 MachHeaderSection *header = nullptr;
|
|
173
|
70 StringTableSection *stringTableSection = nullptr;
|
|
|
71 SymtabSection *symtabSection = nullptr;
|
|
207
|
72 IndirectSymtabSection *indirectSymtabSection = nullptr;
|
|
|
73 CodeSignatureSection *codeSignatureSection = nullptr;
|
|
|
74 FunctionStartsSection *functionStartsSection = nullptr;
|
|
|
75
|
|
|
76 LCUuid *uuidCommand = nullptr;
|
|
|
77 OutputSegment *linkEditSegment = nullptr;
|
|
173
|
78 };
|
|
|
79
|
|
|
80 // LC_DYLD_INFO_ONLY stores the offsets of symbol import/export information.
|
|
|
81 class LCDyldInfo : public LoadCommand {
|
|
|
82 public:
|
|
207
|
83 LCDyldInfo(RebaseSection *rebaseSection, BindingSection *bindingSection,
|
|
|
84 WeakBindingSection *weakBindingSection,
|
|
173
|
85 LazyBindingSection *lazyBindingSection,
|
|
|
86 ExportSection *exportSection)
|
|
207
|
87 : rebaseSection(rebaseSection), bindingSection(bindingSection),
|
|
|
88 weakBindingSection(weakBindingSection),
|
|
|
89 lazyBindingSection(lazyBindingSection), exportSection(exportSection) {}
|
|
173
|
90
|
|
|
91 uint32_t getSize() const override { return sizeof(dyld_info_command); }
|
|
|
92
|
|
|
93 void writeTo(uint8_t *buf) const override {
|
|
|
94 auto *c = reinterpret_cast<dyld_info_command *>(buf);
|
|
|
95 c->cmd = LC_DYLD_INFO_ONLY;
|
|
|
96 c->cmdsize = getSize();
|
|
207
|
97 if (rebaseSection->isNeeded()) {
|
|
|
98 c->rebase_off = rebaseSection->fileOff;
|
|
|
99 c->rebase_size = rebaseSection->getFileSize();
|
|
|
100 }
|
|
173
|
101 if (bindingSection->isNeeded()) {
|
|
|
102 c->bind_off = bindingSection->fileOff;
|
|
|
103 c->bind_size = bindingSection->getFileSize();
|
|
|
104 }
|
|
207
|
105 if (weakBindingSection->isNeeded()) {
|
|
|
106 c->weak_bind_off = weakBindingSection->fileOff;
|
|
|
107 c->weak_bind_size = weakBindingSection->getFileSize();
|
|
|
108 }
|
|
173
|
109 if (lazyBindingSection->isNeeded()) {
|
|
|
110 c->lazy_bind_off = lazyBindingSection->fileOff;
|
|
|
111 c->lazy_bind_size = lazyBindingSection->getFileSize();
|
|
|
112 }
|
|
|
113 if (exportSection->isNeeded()) {
|
|
|
114 c->export_off = exportSection->fileOff;
|
|
|
115 c->export_size = exportSection->getFileSize();
|
|
|
116 }
|
|
|
117 }
|
|
|
118
|
|
207
|
119 RebaseSection *rebaseSection;
|
|
173
|
120 BindingSection *bindingSection;
|
|
207
|
121 WeakBindingSection *weakBindingSection;
|
|
173
|
122 LazyBindingSection *lazyBindingSection;
|
|
|
123 ExportSection *exportSection;
|
|
|
124 };
|
|
|
125
|
|
207
|
126 class LCFunctionStarts : public LoadCommand {
|
|
|
127 public:
|
|
|
128 explicit LCFunctionStarts(FunctionStartsSection *functionStartsSection)
|
|
|
129 : functionStartsSection(functionStartsSection) {}
|
|
|
130
|
|
|
131 uint32_t getSize() const override { return sizeof(linkedit_data_command); }
|
|
|
132
|
|
|
133 void writeTo(uint8_t *buf) const override {
|
|
|
134 auto *c = reinterpret_cast<linkedit_data_command *>(buf);
|
|
|
135 c->cmd = LC_FUNCTION_STARTS;
|
|
|
136 c->cmdsize = getSize();
|
|
|
137 c->dataoff = functionStartsSection->fileOff;
|
|
|
138 c->datasize = functionStartsSection->getFileSize();
|
|
|
139 }
|
|
|
140
|
|
|
141 private:
|
|
|
142 FunctionStartsSection *functionStartsSection;
|
|
|
143 };
|
|
|
144
|
|
173
|
145 class LCDysymtab : public LoadCommand {
|
|
|
146 public:
|
|
207
|
147 LCDysymtab(SymtabSection *symtabSection,
|
|
|
148 IndirectSymtabSection *indirectSymtabSection)
|
|
|
149 : symtabSection(symtabSection),
|
|
|
150 indirectSymtabSection(indirectSymtabSection) {}
|
|
|
151
|
|
173
|
152 uint32_t getSize() const override { return sizeof(dysymtab_command); }
|
|
|
153
|
|
|
154 void writeTo(uint8_t *buf) const override {
|
|
|
155 auto *c = reinterpret_cast<dysymtab_command *>(buf);
|
|
|
156 c->cmd = LC_DYSYMTAB;
|
|
|
157 c->cmdsize = getSize();
|
|
207
|
158
|
|
|
159 c->ilocalsym = 0;
|
|
|
160 c->iextdefsym = c->nlocalsym = symtabSection->getNumLocalSymbols();
|
|
|
161 c->nextdefsym = symtabSection->getNumExternalSymbols();
|
|
|
162 c->iundefsym = c->iextdefsym + c->nextdefsym;
|
|
|
163 c->nundefsym = symtabSection->getNumUndefinedSymbols();
|
|
|
164
|
|
|
165 c->indirectsymoff = indirectSymtabSection->fileOff;
|
|
|
166 c->nindirectsyms = indirectSymtabSection->getNumSymbols();
|
|
173
|
167 }
|
|
207
|
168
|
|
|
169 SymtabSection *symtabSection;
|
|
|
170 IndirectSymtabSection *indirectSymtabSection;
|
|
173
|
171 };
|
|
|
172
|
|
207
|
173 template <class LP> class LCSegment : public LoadCommand {
|
|
173
|
174 public:
|
|
|
175 LCSegment(StringRef name, OutputSegment *seg) : name(name), seg(seg) {}
|
|
|
176
|
|
|
177 uint32_t getSize() const override {
|
|
207
|
178 return sizeof(typename LP::segment_command) +
|
|
|
179 seg->numNonHiddenSections() * sizeof(typename LP::section);
|
|
173
|
180 }
|
|
|
181
|
|
|
182 void writeTo(uint8_t *buf) const override {
|
|
207
|
183 using SegmentCommand = typename LP::segment_command;
|
|
|
184 using Section = typename LP::section;
|
|
173
|
185
|
|
207
|
186 auto *c = reinterpret_cast<SegmentCommand *>(buf);
|
|
|
187 buf += sizeof(SegmentCommand);
|
|
|
188
|
|
|
189 c->cmd = LP::segmentLCType;
|
|
173
|
190 c->cmdsize = getSize();
|
|
|
191 memcpy(c->segname, name.data(), name.size());
|
|
|
192 c->fileoff = seg->fileOff;
|
|
|
193 c->maxprot = seg->maxProt;
|
|
|
194 c->initprot = seg->initProt;
|
|
|
195
|
|
|
196 if (seg->getSections().empty())
|
|
|
197 return;
|
|
|
198
|
|
|
199 c->vmaddr = seg->firstSection()->addr;
|
|
207
|
200 c->vmsize = seg->vmSize;
|
|
|
201 c->filesize = seg->fileSize;
|
|
173
|
202 c->nsects = seg->numNonHiddenSections();
|
|
|
203
|
|
207
|
204 for (const OutputSection *osec : seg->getSections()) {
|
|
|
205 if (osec->isHidden())
|
|
173
|
206 continue;
|
|
|
207
|
|
207
|
208 auto *sectHdr = reinterpret_cast<Section *>(buf);
|
|
|
209 buf += sizeof(Section);
|
|
173
|
210
|
|
207
|
211 memcpy(sectHdr->sectname, osec->name.data(), osec->name.size());
|
|
173
|
212 memcpy(sectHdr->segname, name.data(), name.size());
|
|
|
213
|
|
207
|
214 sectHdr->addr = osec->addr;
|
|
|
215 sectHdr->offset = osec->fileOff;
|
|
|
216 sectHdr->align = Log2_32(osec->align);
|
|
|
217 sectHdr->flags = osec->flags;
|
|
|
218 sectHdr->size = osec->getSize();
|
|
|
219 sectHdr->reserved1 = osec->reserved1;
|
|
|
220 sectHdr->reserved2 = osec->reserved2;
|
|
173
|
221 }
|
|
|
222 }
|
|
|
223
|
|
|
224 private:
|
|
|
225 StringRef name;
|
|
|
226 OutputSegment *seg;
|
|
|
227 };
|
|
|
228
|
|
|
229 class LCMain : public LoadCommand {
|
|
207
|
230 uint32_t getSize() const override {
|
|
|
231 return sizeof(structs::entry_point_command);
|
|
|
232 }
|
|
173
|
233
|
|
|
234 void writeTo(uint8_t *buf) const override {
|
|
207
|
235 auto *c = reinterpret_cast<structs::entry_point_command *>(buf);
|
|
173
|
236 c->cmd = LC_MAIN;
|
|
|
237 c->cmdsize = getSize();
|
|
207
|
238
|
|
|
239 if (config->entry->isInStubs())
|
|
|
240 c->entryoff =
|
|
|
241 in.stubs->fileOff + config->entry->stubsIndex * target->stubSize;
|
|
|
242 else
|
|
|
243 c->entryoff = config->entry->getFileOffset();
|
|
|
244
|
|
173
|
245 c->stacksize = 0;
|
|
|
246 }
|
|
|
247 };
|
|
|
248
|
|
|
249 class LCSymtab : public LoadCommand {
|
|
|
250 public:
|
|
|
251 LCSymtab(SymtabSection *symtabSection, StringTableSection *stringTableSection)
|
|
|
252 : symtabSection(symtabSection), stringTableSection(stringTableSection) {}
|
|
|
253
|
|
|
254 uint32_t getSize() const override { return sizeof(symtab_command); }
|
|
|
255
|
|
|
256 void writeTo(uint8_t *buf) const override {
|
|
|
257 auto *c = reinterpret_cast<symtab_command *>(buf);
|
|
|
258 c->cmd = LC_SYMTAB;
|
|
|
259 c->cmdsize = getSize();
|
|
|
260 c->symoff = symtabSection->fileOff;
|
|
|
261 c->nsyms = symtabSection->getNumSymbols();
|
|
|
262 c->stroff = stringTableSection->fileOff;
|
|
|
263 c->strsize = stringTableSection->getFileSize();
|
|
|
264 }
|
|
|
265
|
|
|
266 SymtabSection *symtabSection = nullptr;
|
|
|
267 StringTableSection *stringTableSection = nullptr;
|
|
|
268 };
|
|
|
269
|
|
|
270 // There are several dylib load commands that share the same structure:
|
|
|
271 // * LC_LOAD_DYLIB
|
|
|
272 // * LC_ID_DYLIB
|
|
|
273 // * LC_REEXPORT_DYLIB
|
|
|
274 class LCDylib : public LoadCommand {
|
|
|
275 public:
|
|
207
|
276 LCDylib(LoadCommandType type, StringRef path,
|
|
|
277 uint32_t compatibilityVersion = 0, uint32_t currentVersion = 0)
|
|
|
278 : type(type), path(path), compatibilityVersion(compatibilityVersion),
|
|
|
279 currentVersion(currentVersion) {
|
|
|
280 instanceCount++;
|
|
|
281 }
|
|
173
|
282
|
|
|
283 uint32_t getSize() const override {
|
|
|
284 return alignTo(sizeof(dylib_command) + path.size() + 1, 8);
|
|
|
285 }
|
|
|
286
|
|
|
287 void writeTo(uint8_t *buf) const override {
|
|
|
288 auto *c = reinterpret_cast<dylib_command *>(buf);
|
|
|
289 buf += sizeof(dylib_command);
|
|
|
290
|
|
|
291 c->cmd = type;
|
|
|
292 c->cmdsize = getSize();
|
|
|
293 c->dylib.name = sizeof(dylib_command);
|
|
207
|
294 c->dylib.timestamp = 0;
|
|
|
295 c->dylib.compatibility_version = compatibilityVersion;
|
|
|
296 c->dylib.current_version = currentVersion;
|
|
173
|
297
|
|
|
298 memcpy(buf, path.data(), path.size());
|
|
|
299 buf[path.size()] = '\0';
|
|
|
300 }
|
|
|
301
|
|
207
|
302 static uint32_t getInstanceCount() { return instanceCount; }
|
|
|
303
|
|
173
|
304 private:
|
|
|
305 LoadCommandType type;
|
|
|
306 StringRef path;
|
|
207
|
307 uint32_t compatibilityVersion;
|
|
|
308 uint32_t currentVersion;
|
|
|
309 static uint32_t instanceCount;
|
|
173
|
310 };
|
|
|
311
|
|
207
|
312 uint32_t LCDylib::instanceCount = 0;
|
|
|
313
|
|
173
|
314 class LCLoadDylinker : public LoadCommand {
|
|
|
315 public:
|
|
|
316 uint32_t getSize() const override {
|
|
|
317 return alignTo(sizeof(dylinker_command) + path.size() + 1, 8);
|
|
|
318 }
|
|
|
319
|
|
|
320 void writeTo(uint8_t *buf) const override {
|
|
|
321 auto *c = reinterpret_cast<dylinker_command *>(buf);
|
|
|
322 buf += sizeof(dylinker_command);
|
|
|
323
|
|
|
324 c->cmd = LC_LOAD_DYLINKER;
|
|
|
325 c->cmdsize = getSize();
|
|
|
326 c->name = sizeof(dylinker_command);
|
|
|
327
|
|
|
328 memcpy(buf, path.data(), path.size());
|
|
|
329 buf[path.size()] = '\0';
|
|
|
330 }
|
|
|
331
|
|
|
332 private:
|
|
|
333 // Recent versions of Darwin won't run any binary that has dyld at a
|
|
|
334 // different location.
|
|
|
335 const StringRef path = "/usr/lib/dyld";
|
|
|
336 };
|
|
207
|
337
|
|
|
338 class LCRPath : public LoadCommand {
|
|
|
339 public:
|
|
|
340 explicit LCRPath(StringRef path) : path(path) {}
|
|
|
341
|
|
|
342 uint32_t getSize() const override {
|
|
|
343 return alignTo(sizeof(rpath_command) + path.size() + 1, target->wordSize);
|
|
|
344 }
|
|
|
345
|
|
|
346 void writeTo(uint8_t *buf) const override {
|
|
|
347 auto *c = reinterpret_cast<rpath_command *>(buf);
|
|
|
348 buf += sizeof(rpath_command);
|
|
|
349
|
|
|
350 c->cmd = LC_RPATH;
|
|
|
351 c->cmdsize = getSize();
|
|
|
352 c->path = sizeof(rpath_command);
|
|
|
353
|
|
|
354 memcpy(buf, path.data(), path.size());
|
|
|
355 buf[path.size()] = '\0';
|
|
|
356 }
|
|
|
357
|
|
|
358 private:
|
|
|
359 StringRef path;
|
|
|
360 };
|
|
|
361
|
|
|
362 class LCMinVersion : public LoadCommand {
|
|
|
363 public:
|
|
|
364 explicit LCMinVersion(const PlatformInfo &platformInfo)
|
|
|
365 : platformInfo(platformInfo) {}
|
|
|
366
|
|
|
367 uint32_t getSize() const override { return sizeof(version_min_command); }
|
|
|
368
|
|
|
369 void writeTo(uint8_t *buf) const override {
|
|
|
370 auto *c = reinterpret_cast<version_min_command *>(buf);
|
|
|
371 switch (platformInfo.target.Platform) {
|
|
|
372 case PlatformKind::macOS:
|
|
|
373 c->cmd = LC_VERSION_MIN_MACOSX;
|
|
|
374 break;
|
|
|
375 case PlatformKind::iOS:
|
|
|
376 case PlatformKind::iOSSimulator:
|
|
|
377 c->cmd = LC_VERSION_MIN_IPHONEOS;
|
|
|
378 break;
|
|
|
379 case PlatformKind::tvOS:
|
|
|
380 case PlatformKind::tvOSSimulator:
|
|
|
381 c->cmd = LC_VERSION_MIN_TVOS;
|
|
|
382 break;
|
|
|
383 case PlatformKind::watchOS:
|
|
|
384 case PlatformKind::watchOSSimulator:
|
|
|
385 c->cmd = LC_VERSION_MIN_WATCHOS;
|
|
|
386 break;
|
|
|
387 default:
|
|
|
388 llvm_unreachable("invalid platform");
|
|
|
389 break;
|
|
|
390 }
|
|
|
391 c->cmdsize = getSize();
|
|
|
392 c->version = encodeVersion(platformInfo.minimum);
|
|
|
393 c->sdk = encodeVersion(platformInfo.sdk);
|
|
|
394 }
|
|
|
395
|
|
|
396 private:
|
|
|
397 const PlatformInfo &platformInfo;
|
|
|
398 };
|
|
|
399
|
|
|
400 class LCBuildVersion : public LoadCommand {
|
|
|
401 public:
|
|
|
402 explicit LCBuildVersion(const PlatformInfo &platformInfo)
|
|
|
403 : platformInfo(platformInfo) {}
|
|
|
404
|
|
|
405 const int ntools = 1;
|
|
|
406
|
|
|
407 uint32_t getSize() const override {
|
|
|
408 return sizeof(build_version_command) + ntools * sizeof(build_tool_version);
|
|
|
409 }
|
|
|
410
|
|
|
411 void writeTo(uint8_t *buf) const override {
|
|
|
412 auto *c = reinterpret_cast<build_version_command *>(buf);
|
|
|
413 c->cmd = LC_BUILD_VERSION;
|
|
|
414 c->cmdsize = getSize();
|
|
|
415 c->platform = static_cast<uint32_t>(platformInfo.target.Platform);
|
|
|
416 c->minos = encodeVersion(platformInfo.minimum);
|
|
|
417 c->sdk = encodeVersion(platformInfo.sdk);
|
|
|
418 c->ntools = ntools;
|
|
|
419 auto *t = reinterpret_cast<build_tool_version *>(&c[1]);
|
|
|
420 t->tool = TOOL_LD;
|
|
|
421 t->version = encodeVersion(llvm::VersionTuple(
|
|
|
422 LLVM_VERSION_MAJOR, LLVM_VERSION_MINOR, LLVM_VERSION_PATCH));
|
|
|
423 }
|
|
|
424
|
|
|
425 private:
|
|
|
426 const PlatformInfo &platformInfo;
|
|
|
427 };
|
|
|
428
|
|
|
429 // Stores a unique identifier for the output file based on an MD5 hash of its
|
|
|
430 // contents. In order to hash the contents, we must first write them, but
|
|
|
431 // LC_UUID itself must be part of the written contents in order for all the
|
|
|
432 // offsets to be calculated correctly. We resolve this circular paradox by
|
|
|
433 // first writing an LC_UUID with an all-zero UUID, then updating the UUID with
|
|
|
434 // its real value later.
|
|
|
435 class LCUuid : public LoadCommand {
|
|
|
436 public:
|
|
|
437 uint32_t getSize() const override { return sizeof(uuid_command); }
|
|
|
438
|
|
|
439 void writeTo(uint8_t *buf) const override {
|
|
|
440 auto *c = reinterpret_cast<uuid_command *>(buf);
|
|
|
441 c->cmd = LC_UUID;
|
|
|
442 c->cmdsize = getSize();
|
|
|
443 uuidBuf = c->uuid;
|
|
|
444 }
|
|
|
445
|
|
|
446 void writeUuid(uint64_t digest) const {
|
|
|
447 // xxhash only gives us 8 bytes, so put some fixed data in the other half.
|
|
|
448 static_assert(sizeof(uuid_command::uuid) == 16, "unexpected uuid size");
|
|
|
449 memcpy(uuidBuf, "LLD\xa1UU1D", 8);
|
|
|
450 memcpy(uuidBuf + 8, &digest, 8);
|
|
|
451
|
|
|
452 // RFC 4122 conformance. We need to fix 4 bits in byte 6 and 2 bits in
|
|
|
453 // byte 8. Byte 6 is already fine due to the fixed data we put in. We don't
|
|
|
454 // want to lose bits of the digest in byte 8, so swap that with a byte of
|
|
|
455 // fixed data that happens to have the right bits set.
|
|
|
456 std::swap(uuidBuf[3], uuidBuf[8]);
|
|
|
457
|
|
|
458 // Claim that this is an MD5-based hash. It isn't, but this signals that
|
|
|
459 // this is not a time-based and not a random hash. MD5 seems like the least
|
|
|
460 // bad lie we can put here.
|
|
|
461 assert((uuidBuf[6] & 0xf0) == 0x30 && "See RFC 4122 Sections 4.2.2, 4.1.3");
|
|
|
462 assert((uuidBuf[8] & 0xc0) == 0x80 && "See RFC 4122 Section 4.2.2");
|
|
|
463 }
|
|
|
464
|
|
|
465 mutable uint8_t *uuidBuf;
|
|
|
466 };
|
|
|
467
|
|
|
468 template <class LP> class LCEncryptionInfo : public LoadCommand {
|
|
|
469 public:
|
|
|
470 uint32_t getSize() const override {
|
|
|
471 return sizeof(typename LP::encryption_info_command);
|
|
|
472 }
|
|
|
473
|
|
|
474 void writeTo(uint8_t *buf) const override {
|
|
|
475 using EncryptionInfo = typename LP::encryption_info_command;
|
|
|
476 auto *c = reinterpret_cast<EncryptionInfo *>(buf);
|
|
|
477 buf += sizeof(EncryptionInfo);
|
|
|
478 c->cmd = LP::encryptionInfoLCType;
|
|
|
479 c->cmdsize = getSize();
|
|
|
480 c->cryptoff = in.header->getSize();
|
|
|
481 auto it = find_if(outputSegments, [](const OutputSegment *seg) {
|
|
|
482 return seg->name == segment_names::text;
|
|
|
483 });
|
|
|
484 assert(it != outputSegments.end());
|
|
|
485 c->cryptsize = (*it)->fileSize - c->cryptoff;
|
|
|
486 }
|
|
|
487 };
|
|
|
488
|
|
|
489 class LCCodeSignature : public LoadCommand {
|
|
|
490 public:
|
|
|
491 LCCodeSignature(CodeSignatureSection *section) : section(section) {}
|
|
|
492
|
|
|
493 uint32_t getSize() const override { return sizeof(linkedit_data_command); }
|
|
|
494
|
|
|
495 void writeTo(uint8_t *buf) const override {
|
|
|
496 auto *c = reinterpret_cast<linkedit_data_command *>(buf);
|
|
|
497 c->cmd = LC_CODE_SIGNATURE;
|
|
|
498 c->cmdsize = getSize();
|
|
|
499 c->dataoff = static_cast<uint32_t>(section->fileOff);
|
|
|
500 c->datasize = section->getSize();
|
|
|
501 }
|
|
|
502
|
|
|
503 CodeSignatureSection *section;
|
|
|
504 };
|
|
|
505
|
|
173
|
506 } // namespace
|
|
|
507
|
|
207
|
508 // Add stubs and bindings where necessary (e.g. if the symbol is a
|
|
|
509 // DylibSymbol.)
|
|
|
510 static void prepareBranchTarget(Symbol *sym) {
|
|
|
511 if (auto *dysym = dyn_cast<DylibSymbol>(sym)) {
|
|
|
512 if (in.stubs->addEntry(dysym)) {
|
|
|
513 if (sym->isWeakDef()) {
|
|
|
514 in.binding->addEntry(dysym, in.lazyPointers->isec,
|
|
|
515 sym->stubsIndex * target->wordSize);
|
|
|
516 in.weakBinding->addEntry(sym, in.lazyPointers->isec,
|
|
|
517 sym->stubsIndex * target->wordSize);
|
|
|
518 } else {
|
|
|
519 in.lazyBinding->addEntry(dysym);
|
|
|
520 }
|
|
|
521 }
|
|
|
522 } else if (auto *defined = dyn_cast<Defined>(sym)) {
|
|
|
523 if (defined->isExternalWeakDef()) {
|
|
|
524 if (in.stubs->addEntry(sym)) {
|
|
|
525 in.rebase->addEntry(in.lazyPointers->isec,
|
|
|
526 sym->stubsIndex * target->wordSize);
|
|
|
527 in.weakBinding->addEntry(sym, in.lazyPointers->isec,
|
|
|
528 sym->stubsIndex * target->wordSize);
|
|
|
529 }
|
|
|
530 }
|
|
|
531 } else {
|
|
|
532 llvm_unreachable("invalid branch target symbol type");
|
|
|
533 }
|
|
|
534 }
|
|
|
535
|
|
|
536 // Can a symbol's address can only be resolved at runtime?
|
|
|
537 static bool needsBinding(const Symbol *sym) {
|
|
|
538 if (isa<DylibSymbol>(sym))
|
|
|
539 return true;
|
|
|
540 if (const auto *defined = dyn_cast<Defined>(sym))
|
|
|
541 return defined->isExternalWeakDef();
|
|
|
542 return false;
|
|
|
543 }
|
|
|
544
|
|
|
545 static void prepareSymbolRelocation(Symbol *sym, const InputSection *isec,
|
|
|
546 const Reloc &r) {
|
|
|
547 const RelocAttrs &relocAttrs = target->getRelocAttrs(r.type);
|
|
|
548
|
|
|
549 if (relocAttrs.hasAttr(RelocAttrBits::BRANCH)) {
|
|
|
550 prepareBranchTarget(sym);
|
|
|
551 } else if (relocAttrs.hasAttr(RelocAttrBits::GOT)) {
|
|
|
552 if (relocAttrs.hasAttr(RelocAttrBits::POINTER) || needsBinding(sym))
|
|
|
553 in.got->addEntry(sym);
|
|
|
554 } else if (relocAttrs.hasAttr(RelocAttrBits::TLV)) {
|
|
|
555 if (needsBinding(sym))
|
|
|
556 in.tlvPointers->addEntry(sym);
|
|
|
557 } else if (relocAttrs.hasAttr(RelocAttrBits::UNSIGNED)) {
|
|
|
558 // References from thread-local variable sections are treated as offsets
|
|
|
559 // relative to the start of the referent section, and therefore have no
|
|
|
560 // need of rebase opcodes.
|
|
|
561 if (!(isThreadLocalVariables(isec->flags) && isa<Defined>(sym)))
|
|
|
562 addNonLazyBindingEntries(sym, isec, r.offset, r.addend);
|
|
|
563 }
|
|
|
564 }
|
|
|
565
|
|
173
|
566 void Writer::scanRelocations() {
|
|
207
|
567 TimeTraceScope timeScope("Scan relocations");
|
|
|
568 for (InputSection *isec : inputSections) {
|
|
|
569 if (isec->shouldOmitFromOutput())
|
|
|
570 continue;
|
|
|
571
|
|
|
572 if (isec->segname == segment_names::ld) {
|
|
|
573 in.unwindInfo->prepareRelocations(isec);
|
|
|
574 continue;
|
|
|
575 }
|
|
|
576
|
|
|
577 for (auto it = isec->relocs.begin(); it != isec->relocs.end(); ++it) {
|
|
|
578 Reloc &r = *it;
|
|
|
579 if (target->hasAttr(r.type, RelocAttrBits::SUBTRAHEND)) {
|
|
|
580 // Skip over the following UNSIGNED relocation -- it's just there as the
|
|
|
581 // minuend, and doesn't have the usual UNSIGNED semantics. We don't want
|
|
|
582 // to emit rebase opcodes for it.
|
|
|
583 it++;
|
|
|
584 continue;
|
|
|
585 }
|
|
|
586 if (auto *sym = r.referent.dyn_cast<Symbol *>()) {
|
|
|
587 if (auto *undefined = dyn_cast<Undefined>(sym))
|
|
|
588 treatUndefinedSymbol(*undefined);
|
|
|
589 // treatUndefinedSymbol() can replace sym with a DylibSymbol; re-check.
|
|
|
590 if (!isa<Undefined>(sym) && validateSymbolRelocation(sym, isec, r))
|
|
|
591 prepareSymbolRelocation(sym, isec, r);
|
|
|
592 } else {
|
|
|
593 assert(r.referent.is<InputSection *>());
|
|
|
594 assert(!r.referent.get<InputSection *>()->shouldOmitFromOutput());
|
|
|
595 if (!r.pcrel)
|
|
|
596 in.rebase->addEntry(isec, r.offset);
|
|
|
597 }
|
|
|
598 }
|
|
|
599 }
|
|
173
|
600 }
|
|
|
601
|
|
207
|
602 void Writer::scanSymbols() {
|
|
|
603 TimeTraceScope timeScope("Scan symbols");
|
|
|
604 for (const Symbol *sym : symtab->getSymbols()) {
|
|
|
605 if (const auto *defined = dyn_cast<Defined>(sym)) {
|
|
|
606 if (defined->overridesWeakDef && defined->isLive())
|
|
|
607 in.weakBinding->addNonWeakDefinition(defined);
|
|
|
608 } else if (const auto *dysym = dyn_cast<DylibSymbol>(sym)) {
|
|
|
609 // This branch intentionally doesn't check isLive().
|
|
|
610 if (dysym->isDynamicLookup())
|
|
|
611 continue;
|
|
|
612 dysym->getFile()->refState =
|
|
|
613 std::max(dysym->getFile()->refState, dysym->getRefState());
|
|
|
614 }
|
|
|
615 }
|
|
|
616 }
|
|
|
617
|
|
|
618 // TODO: ld64 enforces the old load commands in a few other cases.
|
|
|
619 static bool useLCBuildVersion(const PlatformInfo &platformInfo) {
|
|
|
620 static const std::map<PlatformKind, llvm::VersionTuple> minVersion = {
|
|
|
621 {PlatformKind::macOS, llvm::VersionTuple(10, 14)},
|
|
|
622 {PlatformKind::iOS, llvm::VersionTuple(12, 0)},
|
|
|
623 {PlatformKind::iOSSimulator, llvm::VersionTuple(13, 0)},
|
|
|
624 {PlatformKind::tvOS, llvm::VersionTuple(12, 0)},
|
|
|
625 {PlatformKind::tvOSSimulator, llvm::VersionTuple(13, 0)},
|
|
|
626 {PlatformKind::watchOS, llvm::VersionTuple(5, 0)},
|
|
|
627 {PlatformKind::watchOSSimulator, llvm::VersionTuple(6, 0)}};
|
|
|
628 auto it = minVersion.find(platformInfo.target.Platform);
|
|
|
629 return it == minVersion.end() ? true : platformInfo.minimum >= it->second;
|
|
|
630 }
|
|
|
631
|
|
|
632 template <class LP> void Writer::createLoadCommands() {
|
|
|
633 uint8_t segIndex = 0;
|
|
|
634 for (OutputSegment *seg : outputSegments) {
|
|
|
635 in.header->addLoadCommand(make<LCSegment<LP>>(seg->name, seg));
|
|
|
636 seg->index = segIndex++;
|
|
|
637 }
|
|
|
638
|
|
|
639 in.header->addLoadCommand(make<LCDyldInfo>(
|
|
|
640 in.rebase, in.binding, in.weakBinding, in.lazyBinding, in.exports));
|
|
|
641 in.header->addLoadCommand(make<LCSymtab>(symtabSection, stringTableSection));
|
|
|
642 in.header->addLoadCommand(
|
|
|
643 make<LCDysymtab>(symtabSection, indirectSymtabSection));
|
|
|
644 if (functionStartsSection)
|
|
|
645 in.header->addLoadCommand(make<LCFunctionStarts>(functionStartsSection));
|
|
|
646 if (config->emitEncryptionInfo)
|
|
|
647 in.header->addLoadCommand(make<LCEncryptionInfo<LP>>());
|
|
|
648 for (StringRef path : config->runtimePaths)
|
|
|
649 in.header->addLoadCommand(make<LCRPath>(path));
|
|
173
|
650
|
|
|
651 switch (config->outputType) {
|
|
|
652 case MH_EXECUTE:
|
|
207
|
653 in.header->addLoadCommand(make<LCLoadDylinker>());
|
|
|
654 in.header->addLoadCommand(make<LCMain>());
|
|
173
|
655 break;
|
|
|
656 case MH_DYLIB:
|
|
207
|
657 in.header->addLoadCommand(make<LCDylib>(LC_ID_DYLIB, config->installName,
|
|
|
658 config->dylibCompatibilityVersion,
|
|
|
659 config->dylibCurrentVersion));
|
|
|
660 break;
|
|
|
661 case MH_BUNDLE:
|
|
173
|
662 break;
|
|
|
663 default:
|
|
|
664 llvm_unreachable("unhandled output file type");
|
|
|
665 }
|
|
|
666
|
|
207
|
667 uuidCommand = make<LCUuid>();
|
|
|
668 in.header->addLoadCommand(uuidCommand);
|
|
173
|
669
|
|
207
|
670 if (useLCBuildVersion(config->platformInfo))
|
|
|
671 in.header->addLoadCommand(make<LCBuildVersion>(config->platformInfo));
|
|
|
672 else
|
|
|
673 in.header->addLoadCommand(make<LCMinVersion>(config->platformInfo));
|
|
|
674
|
|
|
675 int64_t dylibOrdinal = 1;
|
|
|
676 DenseMap<StringRef, int64_t> ordinalForInstallName;
|
|
173
|
677 for (InputFile *file : inputFiles) {
|
|
|
678 if (auto *dylibFile = dyn_cast<DylibFile>(file)) {
|
|
207
|
679 if (dylibFile->isBundleLoader) {
|
|
|
680 dylibFile->ordinal = BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE;
|
|
|
681 // Shortcut since bundle-loader does not re-export the symbols.
|
|
|
682
|
|
|
683 dylibFile->reexport = false;
|
|
|
684 continue;
|
|
|
685 }
|
|
|
686
|
|
|
687 // Don't emit load commands for a dylib that is not referenced if:
|
|
|
688 // - it was added implicitly (via a reexport, an LC_LOAD_DYLINKER --
|
|
|
689 // if it's on the linker command line, it's explicit)
|
|
|
690 // - or it's marked MH_DEAD_STRIPPABLE_DYLIB
|
|
|
691 // - or the flag -dead_strip_dylibs is used
|
|
|
692 // FIXME: `isReferenced()` is currently computed before dead code
|
|
|
693 // stripping, so references from dead code keep a dylib alive. This
|
|
|
694 // matches ld64, but it's something we should do better.
|
|
|
695 if (!dylibFile->isReferenced() && !dylibFile->forceNeeded &&
|
|
|
696 (!dylibFile->explicitlyLinked || dylibFile->deadStrippable ||
|
|
|
697 config->deadStripDylibs))
|
|
|
698 continue;
|
|
|
699
|
|
|
700 // Several DylibFiles can have the same installName. Only emit a single
|
|
|
701 // load command for that installName and give all these DylibFiles the
|
|
|
702 // same ordinal.
|
|
|
703 // This can happen in several cases:
|
|
|
704 // - a new framework could change its installName to an older
|
|
|
705 // framework name via an $ld$ symbol depending on platform_version
|
|
|
706 // - symlinks (for example, libpthread.tbd is a symlink to libSystem.tbd;
|
|
|
707 // Foo.framework/Foo.tbd is usually a symlink to
|
|
|
708 // Foo.framework/Versions/Current/Foo.tbd, where
|
|
|
709 // Foo.framework/Versions/Current is usually a symlink to
|
|
|
710 // Foo.framework/Versions/A)
|
|
|
711 // - a framework can be linked both explicitly on the linker
|
|
|
712 // command line and implicitly as a reexport from a different
|
|
|
713 // framework. The re-export will usually point to the tbd file
|
|
|
714 // in Foo.framework/Versions/A/Foo.tbd, while the explicit link will
|
|
|
715 // usually find Foo.framwork/Foo.tbd. These are usually symlinks,
|
|
|
716 // but in a --reproduce archive they will be identical but distinct
|
|
|
717 // files.
|
|
|
718 // In the first case, *semantically distinct* DylibFiles will have the
|
|
|
719 // same installName.
|
|
|
720 int64_t &ordinal = ordinalForInstallName[dylibFile->installName];
|
|
|
721 if (ordinal) {
|
|
|
722 dylibFile->ordinal = ordinal;
|
|
|
723 continue;
|
|
|
724 }
|
|
|
725
|
|
|
726 ordinal = dylibFile->ordinal = dylibOrdinal++;
|
|
|
727 LoadCommandType lcType =
|
|
|
728 dylibFile->forceWeakImport || dylibFile->refState == RefState::Weak
|
|
|
729 ? LC_LOAD_WEAK_DYLIB
|
|
|
730 : LC_LOAD_DYLIB;
|
|
|
731 in.header->addLoadCommand(make<LCDylib>(lcType, dylibFile->installName,
|
|
|
732 dylibFile->compatibilityVersion,
|
|
|
733 dylibFile->currentVersion));
|
|
173
|
734
|
|
|
735 if (dylibFile->reexport)
|
|
207
|
736 in.header->addLoadCommand(
|
|
|
737 make<LCDylib>(LC_REEXPORT_DYLIB, dylibFile->installName));
|
|
173
|
738 }
|
|
|
739 }
|
|
207
|
740
|
|
|
741 if (codeSignatureSection)
|
|
|
742 in.header->addLoadCommand(make<LCCodeSignature>(codeSignatureSection));
|
|
|
743
|
|
|
744 const uint32_t MACOS_MAXPATHLEN = 1024;
|
|
|
745 config->headerPad = std::max(
|
|
|
746 config->headerPad, (config->headerPadMaxInstallNames
|
|
|
747 ? LCDylib::getInstanceCount() * MACOS_MAXPATHLEN
|
|
|
748 : 0));
|
|
173
|
749 }
|
|
|
750
|
|
|
751 static size_t getSymbolPriority(const SymbolPriorityEntry &entry,
|
|
207
|
752 const InputFile *f) {
|
|
|
753 // We don't use toString(InputFile *) here because it returns the full path
|
|
|
754 // for object files, and we only want the basename.
|
|
|
755 StringRef filename;
|
|
|
756 if (f->archiveName.empty())
|
|
|
757 filename = path::filename(f->getName());
|
|
|
758 else
|
|
|
759 filename = saver.save(path::filename(f->archiveName) + "(" +
|
|
|
760 path::filename(f->getName()) + ")");
|
|
|
761 return std::max(entry.objectFiles.lookup(filename), entry.anyObjectFile);
|
|
173
|
762 }
|
|
|
763
|
|
|
764 // Each section gets assigned the priority of the highest-priority symbol it
|
|
|
765 // contains.
|
|
|
766 static DenseMap<const InputSection *, size_t> buildInputSectionPriorities() {
|
|
|
767 DenseMap<const InputSection *, size_t> sectionPriorities;
|
|
|
768
|
|
|
769 if (config->priorities.empty())
|
|
|
770 return sectionPriorities;
|
|
|
771
|
|
|
772 auto addSym = [&](Defined &sym) {
|
|
|
773 auto it = config->priorities.find(sym.getName());
|
|
|
774 if (it == config->priorities.end())
|
|
|
775 return;
|
|
|
776
|
|
|
777 SymbolPriorityEntry &entry = it->second;
|
|
|
778 size_t &priority = sectionPriorities[sym.isec];
|
|
207
|
779 priority = std::max(priority, getSymbolPriority(entry, sym.isec->file));
|
|
173
|
780 };
|
|
|
781
|
|
|
782 // TODO: Make sure this handles weak symbols correctly.
|
|
207
|
783 for (const InputFile *file : inputFiles) {
|
|
|
784 if (isa<ObjFile>(file))
|
|
173
|
785 for (Symbol *sym : file->symbols)
|
|
207
|
786 if (auto *d = dyn_cast_or_null<Defined>(sym))
|
|
173
|
787 addSym(*d);
|
|
207
|
788 }
|
|
173
|
789
|
|
|
790 return sectionPriorities;
|
|
|
791 }
|
|
|
792
|
|
|
793 // Sorting only can happen once all outputs have been collected. Here we sort
|
|
|
794 // segments, output sections within each segment, and input sections within each
|
|
|
795 // output segment.
|
|
|
796 static void sortSegmentsAndSections() {
|
|
207
|
797 TimeTraceScope timeScope("Sort segments and sections");
|
|
|
798 sortOutputSegments();
|
|
173
|
799
|
|
|
800 DenseMap<const InputSection *, size_t> isecPriorities =
|
|
|
801 buildInputSectionPriorities();
|
|
|
802
|
|
|
803 uint32_t sectionIndex = 0;
|
|
|
804 for (OutputSegment *seg : outputSegments) {
|
|
207
|
805 seg->sortOutputSections();
|
|
|
806 for (OutputSection *osec : seg->getSections()) {
|
|
173
|
807 // Now that the output sections are sorted, assign the final
|
|
|
808 // output section indices.
|
|
207
|
809 if (!osec->isHidden())
|
|
|
810 osec->index = ++sectionIndex;
|
|
|
811 if (!firstTLVDataSection && isThreadLocalData(osec->flags))
|
|
|
812 firstTLVDataSection = osec;
|
|
173
|
813
|
|
|
814 if (!isecPriorities.empty()) {
|
|
207
|
815 if (auto *merged = dyn_cast<ConcatOutputSection>(osec)) {
|
|
173
|
816 llvm::stable_sort(merged->inputs,
|
|
|
817 [&](InputSection *a, InputSection *b) {
|
|
|
818 return isecPriorities[a] > isecPriorities[b];
|
|
|
819 });
|
|
|
820 }
|
|
|
821 }
|
|
|
822 }
|
|
|
823 }
|
|
|
824 }
|
|
|
825
|
|
207
|
826 static NamePair maybeRenameSection(NamePair key) {
|
|
|
827 auto newNames = config->sectionRenameMap.find(key);
|
|
|
828 if (newNames != config->sectionRenameMap.end())
|
|
|
829 return newNames->second;
|
|
|
830 auto newName = config->segmentRenameMap.find(key.first);
|
|
|
831 if (newName != config->segmentRenameMap.end())
|
|
|
832 return std::make_pair(newName->second, key.second);
|
|
|
833 return key;
|
|
|
834 }
|
|
|
835
|
|
|
836 template <class LP> void Writer::createOutputSections() {
|
|
|
837 TimeTraceScope timeScope("Create output sections");
|
|
173
|
838 // First, create hidden sections
|
|
|
839 stringTableSection = make<StringTableSection>();
|
|
207
|
840 symtabSection = makeSymtabSection<LP>(*stringTableSection);
|
|
|
841 indirectSymtabSection = make<IndirectSymtabSection>();
|
|
|
842 if (config->adhocCodesign)
|
|
|
843 codeSignatureSection = make<CodeSignatureSection>();
|
|
|
844 if (config->emitFunctionStarts)
|
|
|
845 functionStartsSection = make<FunctionStartsSection>();
|
|
|
846 if (config->emitBitcodeBundle)
|
|
|
847 make<BitcodeBundleSection>();
|
|
173
|
848
|
|
|
849 switch (config->outputType) {
|
|
|
850 case MH_EXECUTE:
|
|
|
851 make<PageZeroSection>();
|
|
|
852 break;
|
|
|
853 case MH_DYLIB:
|
|
207
|
854 case MH_BUNDLE:
|
|
173
|
855 break;
|
|
|
856 default:
|
|
|
857 llvm_unreachable("unhandled output file type");
|
|
|
858 }
|
|
|
859
|
|
207
|
860 // Then add input sections to output sections.
|
|
|
861 DenseMap<NamePair, ConcatOutputSection *> concatOutputSections;
|
|
|
862 for (const auto &p : enumerate(inputSections)) {
|
|
|
863 InputSection *isec = p.value();
|
|
|
864 if (isec->shouldOmitFromOutput())
|
|
|
865 continue;
|
|
|
866 NamePair names = maybeRenameSection({isec->segname, isec->name});
|
|
|
867 ConcatOutputSection *&osec = concatOutputSections[names];
|
|
|
868 if (osec == nullptr) {
|
|
|
869 osec = make<ConcatOutputSection>(names.second);
|
|
|
870 osec->inputOrder = p.index();
|
|
|
871 }
|
|
|
872 osec->addInput(isec);
|
|
|
873 }
|
|
|
874
|
|
|
875 for (const auto &it : concatOutputSections) {
|
|
|
876 StringRef segname = it.first.first;
|
|
|
877 ConcatOutputSection *osec = it.second;
|
|
|
878 if (segname == segment_names::ld) {
|
|
|
879 assert(osec->name == section_names::compactUnwind);
|
|
|
880 in.unwindInfo->setCompactUnwindSection(osec);
|
|
|
881 } else {
|
|
|
882 getOrCreateOutputSegment(segname)->addOutputSection(osec);
|
|
|
883 }
|
|
173
|
884 }
|
|
|
885
|
|
207
|
886 for (SyntheticSection *ssec : syntheticSections) {
|
|
|
887 auto it = concatOutputSections.find({ssec->segname, ssec->name});
|
|
|
888 if (it == concatOutputSections.end()) {
|
|
|
889 if (ssec->isNeeded())
|
|
|
890 getOrCreateOutputSegment(ssec->segname)->addOutputSection(ssec);
|
|
|
891 } else {
|
|
|
892 error("section from " + toString(it->second->firstSection()->file) +
|
|
|
893 " conflicts with synthetic section " + ssec->segname + "," +
|
|
|
894 ssec->name);
|
|
|
895 }
|
|
|
896 }
|
|
|
897
|
|
|
898 // dyld requires __LINKEDIT segment to always exist (even if empty).
|
|
|
899 linkEditSegment = getOrCreateOutputSegment(segment_names::linkEdit);
|
|
|
900 }
|
|
|
901
|
|
|
902 void Writer::finalizeAddresses() {
|
|
|
903 TimeTraceScope timeScope("Finalize addresses");
|
|
|
904 uint64_t pageSize = target->getPageSize();
|
|
|
905 // Ensure that segments (and the sections they contain) are allocated
|
|
|
906 // addresses in ascending order, which dyld requires.
|
|
|
907 //
|
|
|
908 // Note that at this point, __LINKEDIT sections are empty, but we need to
|
|
|
909 // determine addresses of other segments/sections before generating its
|
|
|
910 // contents.
|
|
|
911 for (OutputSegment *seg : outputSegments) {
|
|
|
912 if (seg == linkEditSegment)
|
|
|
913 continue;
|
|
|
914 assignAddresses(seg);
|
|
|
915 // codesign / libstuff checks for segment ordering by verifying that
|
|
|
916 // `fileOff + fileSize == next segment fileOff`. So we call alignTo() before
|
|
|
917 // (instead of after) computing fileSize to ensure that the segments are
|
|
|
918 // contiguous. We handle addr / vmSize similarly for the same reason.
|
|
|
919 fileOff = alignTo(fileOff, pageSize);
|
|
|
920 addr = alignTo(addr, pageSize);
|
|
|
921 seg->vmSize = addr - seg->firstSection()->addr;
|
|
|
922 seg->fileSize = fileOff - seg->fileOff;
|
|
173
|
923 }
|
|
|
924 }
|
|
|
925
|
|
207
|
926 void Writer::finalizeLinkEditSegment() {
|
|
|
927 TimeTraceScope timeScope("Finalize __LINKEDIT segment");
|
|
|
928 // Fill __LINKEDIT contents.
|
|
|
929 std::vector<LinkEditSection *> linkEditSections{
|
|
|
930 in.rebase, in.binding, in.weakBinding, in.lazyBinding,
|
|
|
931 in.exports, symtabSection, indirectSymtabSection, functionStartsSection,
|
|
|
932 };
|
|
|
933 parallelForEach(linkEditSections, [](LinkEditSection *osec) {
|
|
|
934 if (osec)
|
|
|
935 osec->finalizeContents();
|
|
|
936 });
|
|
|
937
|
|
|
938 // Now that __LINKEDIT is filled out, do a proper calculation of its
|
|
|
939 // addresses and offsets.
|
|
|
940 assignAddresses(linkEditSegment);
|
|
|
941 // No need to page-align fileOff / addr here since this is the last segment.
|
|
|
942 linkEditSegment->vmSize = addr - linkEditSegment->firstSection()->addr;
|
|
|
943 linkEditSegment->fileSize = fileOff - linkEditSegment->fileOff;
|
|
|
944 }
|
|
|
945
|
|
173
|
946 void Writer::assignAddresses(OutputSegment *seg) {
|
|
|
947 seg->fileOff = fileOff;
|
|
|
948
|
|
207
|
949 for (OutputSection *osec : seg->getSections()) {
|
|
|
950 if (!osec->isNeeded())
|
|
|
951 continue;
|
|
|
952 addr = alignTo(addr, osec->align);
|
|
|
953 fileOff = alignTo(fileOff, osec->align);
|
|
|
954 osec->addr = addr;
|
|
|
955 osec->fileOff = isZeroFill(osec->flags) ? 0 : fileOff;
|
|
|
956 osec->finalize();
|
|
173
|
957
|
|
207
|
958 addr += osec->getSize();
|
|
|
959 fileOff += osec->getFileSize();
|
|
173
|
960 }
|
|
|
961 }
|
|
|
962
|
|
|
963 void Writer::openFile() {
|
|
|
964 Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
|
|
|
965 FileOutputBuffer::create(config->outputFile, fileOff,
|
|
|
966 FileOutputBuffer::F_executable);
|
|
|
967
|
|
|
968 if (!bufferOrErr)
|
|
|
969 error("failed to open " + config->outputFile + ": " +
|
|
|
970 llvm::toString(bufferOrErr.takeError()));
|
|
|
971 else
|
|
|
972 buffer = std::move(*bufferOrErr);
|
|
|
973 }
|
|
|
974
|
|
|
975 void Writer::writeSections() {
|
|
|
976 uint8_t *buf = buffer->getBufferStart();
|
|
207
|
977 for (const OutputSegment *seg : outputSegments)
|
|
|
978 for (const OutputSection *osec : seg->getSections())
|
|
|
979 osec->writeTo(buf + osec->fileOff);
|
|
173
|
980 }
|
|
|
981
|
|
207
|
982 // In order to utilize multiple cores, we first split the buffer into chunks,
|
|
|
983 // compute a hash for each chunk, and then compute a hash value of the hash
|
|
|
984 // values.
|
|
|
985 void Writer::writeUuid() {
|
|
|
986 TimeTraceScope timeScope("Computing UUID");
|
|
|
987 ArrayRef<uint8_t> data{buffer->getBufferStart(), buffer->getBufferEnd()};
|
|
|
988 unsigned chunkCount = parallel::strategy.compute_thread_count() * 10;
|
|
|
989 // Round-up integer division
|
|
|
990 size_t chunkSize = (data.size() + chunkCount - 1) / chunkCount;
|
|
|
991 std::vector<ArrayRef<uint8_t>> chunks = split(data, chunkSize);
|
|
|
992 std::vector<uint64_t> hashes(chunks.size());
|
|
|
993 parallelForEachN(0, chunks.size(),
|
|
|
994 [&](size_t i) { hashes[i] = xxHash64(chunks[i]); });
|
|
|
995 uint64_t digest = xxHash64({reinterpret_cast<uint8_t *>(hashes.data()),
|
|
|
996 hashes.size() * sizeof(uint64_t)});
|
|
|
997 uuidCommand->writeUuid(digest);
|
|
|
998 }
|
|
173
|
999
|
|
207
|
1000 void Writer::writeCodeSignature() {
|
|
|
1001 if (codeSignatureSection)
|
|
|
1002 codeSignatureSection->writeHashes(buffer->getBufferStart());
|
|
|
1003 }
|
|
173
|
1004
|
|
207
|
1005 void Writer::writeOutputFile() {
|
|
|
1006 TimeTraceScope timeScope("Write output file");
|
|
173
|
1007 openFile();
|
|
|
1008 if (errorCount())
|
|
|
1009 return;
|
|
|
1010 writeSections();
|
|
207
|
1011 writeUuid();
|
|
|
1012 writeCodeSignature();
|
|
173
|
1013
|
|
|
1014 if (auto e = buffer->commit())
|
|
|
1015 error("failed to write to the output file: " + toString(std::move(e)));
|
|
|
1016 }
|
|
|
1017
|
|
207
|
1018 template <class LP> void Writer::run() {
|
|
|
1019 if (config->entry && !isa<Undefined>(config->entry))
|
|
|
1020 prepareBranchTarget(config->entry);
|
|
|
1021 scanRelocations();
|
|
|
1022 if (in.stubHelper->isNeeded())
|
|
|
1023 in.stubHelper->setup();
|
|
|
1024 scanSymbols();
|
|
|
1025 createOutputSections<LP>();
|
|
|
1026 // After this point, we create no new segments; HOWEVER, we might
|
|
|
1027 // yet create branch-range extension thunks for architectures whose
|
|
|
1028 // hardware call instructions have limited range, e.g., ARM(64).
|
|
|
1029 // The thunks are created as InputSections interspersed among
|
|
|
1030 // the ordinary __TEXT,_text InputSections.
|
|
|
1031 sortSegmentsAndSections();
|
|
|
1032 createLoadCommands<LP>();
|
|
|
1033 finalizeAddresses();
|
|
|
1034 finalizeLinkEditSegment();
|
|
|
1035 writeMapFile();
|
|
|
1036 writeOutputFile();
|
|
|
1037 }
|
|
|
1038
|
|
|
1039 template <class LP> void macho::writeResult() { Writer().run<LP>(); }
|
|
173
|
1040
|
|
|
1041 void macho::createSyntheticSections() {
|
|
207
|
1042 in.header = make<MachHeaderSection>();
|
|
|
1043 in.rebase = make<RebaseSection>();
|
|
|
1044 in.binding = make<BindingSection>();
|
|
|
1045 in.weakBinding = make<WeakBindingSection>();
|
|
|
1046 in.lazyBinding = make<LazyBindingSection>();
|
|
|
1047 in.exports = make<ExportSection>();
|
|
173
|
1048 in.got = make<GotSection>();
|
|
207
|
1049 in.tlvPointers = make<TlvPointerSection>();
|
|
173
|
1050 in.lazyPointers = make<LazyPointerSection>();
|
|
|
1051 in.stubs = make<StubsSection>();
|
|
|
1052 in.stubHelper = make<StubHelperSection>();
|
|
|
1053 in.imageLoaderCache = make<ImageLoaderCacheSection>();
|
|
207
|
1054 in.unwindInfo = makeUnwindInfoSection();
|
|
173
|
1055 }
|
|
207
|
1056
|
|
|
1057 OutputSection *macho::firstTLVDataSection = nullptr;
|
|
|
1058
|
|
|
1059 template void macho::writeResult<LP64>();
|
|
|
1060 template void macho::writeResult<ILP32>();
|
