1//===- Writer.cpp ---------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "Writer.h"
10#include "Config.h"
11#include "InputChunks.h"
12#include "InputElement.h"
13#include "MapFile.h"
14#include "OutputSections.h"
15#include "OutputSegment.h"
16#include "Relocations.h"
17#include "SymbolTable.h"
18#include "SyntheticSections.h"
19#include "WriterUtils.h"
20#include "lld/Common/Arrays.h"
21#include "lld/Common/CommonLinkerContext.h"
22#include "lld/Common/Strings.h"
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/MapVector.h"
25#include "llvm/ADT/SmallSet.h"
26#include "llvm/ADT/SmallVector.h"
27#include "llvm/ADT/StringMap.h"
28#include "llvm/BinaryFormat/Wasm.h"
29#include "llvm/Support/FileOutputBuffer.h"
30#include "llvm/Support/FormatVariadic.h"
31#include "llvm/Support/Parallel.h"
32#include "llvm/Support/RandomNumberGenerator.h"
33#include "llvm/Support/SHA1.h"
34#include "llvm/Support/xxhash.h"
35
36#include <cstdarg>
37#include <optional>
38
39#define DEBUG_TYPE "lld"
40
41using namespace llvm;
42using namespace llvm::wasm;
43
44namespace lld::wasm {
45static constexpr int stackAlignment = 16;
46static constexpr int heapAlignment = 16;
47
48namespace {
49
50// The writer writes a SymbolTable result to a file.
51class Writer {
52public:
53 void run();
54
55private:
56 void openFile();
57
58 bool needsPassiveInitialization(const OutputSegment *segment);
59 bool hasPassiveInitializedSegments();
60
61 void createSyntheticInitFunctions();
62 void createInitMemoryFunction();
63 void createStartFunction();
64 void createApplyDataRelocationsFunction();
65 void createApplyGlobalRelocationsFunction();
66 void createApplyTLSRelocationsFunction();
67 void createApplyGlobalTLSRelocationsFunction();
68 void createCallCtorsFunction();
69 void createInitTLSFunction();
70 void createCommandExportWrappers();
71 void createCommandExportWrapper(uint32_t functionIndex, DefinedFunction *f);
72
73 void assignIndexes();
74 void populateSymtab();
75 void populateProducers();
76 void populateTargetFeatures();
77 // populateTargetFeatures happens early on so some checks are delayed
78 // until imports and exports are finalized. There are run unstead
79 // in checkImportExportTargetFeatures
80 void checkImportExportTargetFeatures();
81 void calculateInitFunctions();
82 void calculateImports();
83 void calculateExports();
84 void calculateCustomSections();
85 void calculateTypes();
86 void createOutputSegments();
87 OutputSegment *createOutputSegment(StringRef name);
88 void combineOutputSegments();
89 void layoutMemory();
90 void createHeader();
91
92 void addSection(OutputSection *sec);
93
94 void addSections();
95
96 void createCustomSections();
97 void createSyntheticSections();
98 void createSyntheticSectionsPostLayout();
99 void finalizeSections();
100
101 // Custom sections
102 void createRelocSections();
103
104 void writeHeader();
105 void writeSections();
106 void writeBuildId();
107
108 uint64_t fileSize = 0;
109
110 std::vector<WasmInitEntry> initFunctions;
111 llvm::MapVector<StringRef, std::vector<InputChunk *>> customSectionMapping;
112
113 // Stable storage for command export wrapper function name strings.
114 std::list<std::string> commandExportWrapperNames;
115
116 // Elements that are used to construct the final output
117 std::string header;
118 std::vector<OutputSection *> outputSections;
119
120 std::unique_ptr<FileOutputBuffer> buffer;
121
122 std::vector<OutputSegment *> segments;
123 llvm::SmallDenseMap<StringRef, OutputSegment *> segmentMap;
124};
125
126} // anonymous namespace
127
128void Writer::calculateCustomSections() {
129 log(msg: "calculateCustomSections");
130 bool stripDebug = ctx.arg.stripDebug || ctx.arg.stripAll;
131 for (ObjFile *file : ctx.objectFiles) {
132 for (InputChunk *section : file->customSections) {
133 // Exclude COMDAT sections that are not selected for inclusion
134 if (section->discarded)
135 continue;
136 // Ignore empty custom sections. In particular objcopy/strip will
137 // sometimes replace stripped sections with empty custom sections to
138 // avoid section re-numbering.
139 if (section->getSize() == 0)
140 continue;
141 StringRef name = section->name;
142 // These custom sections are known the linker and synthesized rather than
143 // blindly copied.
144 if (name == "linking" || name == "name" || name == "producers" ||
145 name == "target_features" || name.starts_with(Prefix: "reloc."))
146 continue;
147 // These custom sections are generated by `clang -fembed-bitcode`.
148 // These are used by the rust toolchain to ship LTO data along with
149 // compiled object code, but they don't want this included in the linker
150 // output.
151 if (name == ".llvmbc" || name == ".llvmcmd")
152 continue;
153 // Strip debug section in that option was specified.
154 if (stripDebug && name.starts_with(Prefix: ".debug_"))
155 continue;
156 // Otherwise include custom sections by default and concatenate their
157 // contents.
158 customSectionMapping[name].push_back(x: section);
159 }
160 }
161}
162
163void Writer::createCustomSections() {
164 log(msg: "createCustomSections");
165 for (auto &pair : customSectionMapping) {
166 StringRef name = pair.first;
167 LLVM_DEBUG(dbgs() << "createCustomSection: " << name << "\n");
168
169 OutputSection *sec = make<CustomSection>(args: std::string(name), args&: pair.second);
170 if (ctx.arg.relocatable || ctx.arg.emitRelocs) {
171 auto *sym = make<OutputSectionSymbol>(args&: sec);
172 out.linkingSec->addToSymtab(sym);
173 sec->sectionSym = sym;
174 }
175 addSection(sec);
176 }
177}
178
179// Create relocations sections in the final output.
180// These are only created when relocatable output is requested.
181void Writer::createRelocSections() {
182 log(msg: "createRelocSections");
183 // Don't use iterator here since we are adding to OutputSection
184 size_t origSize = outputSections.size();
185 for (size_t i = 0; i < origSize; i++) {
186 LLVM_DEBUG(dbgs() << "check section " << i << "\n");
187 OutputSection *sec = outputSections[i];
188
189 // Count the number of needed sections.
190 uint32_t count = sec->getNumRelocations();
191 if (!count)
192 continue;
193
194 StringRef name;
195 if (sec->type == WASM_SEC_DATA)
196 name = "reloc.DATA";
197 else if (sec->type == WASM_SEC_CODE)
198 name = "reloc.CODE";
199 else if (sec->type == WASM_SEC_CUSTOM)
200 name = saver().save(S: "reloc." + sec->name);
201 else
202 llvm_unreachable(
203 "relocations only supported for code, data, or custom sections");
204
205 addSection(sec: make<RelocSection>(args&: name, args&: sec));
206 }
207}
208
209void Writer::populateProducers() {
210 for (ObjFile *file : ctx.objectFiles) {
211 const WasmProducerInfo &info = file->getWasmObj()->getProducerInfo();
212 out.producersSec->addInfo(info);
213 }
214}
215
216void Writer::writeHeader() {
217 memcpy(dest: buffer->getBufferStart(), src: header.data(), n: header.size());
218}
219
220void Writer::writeSections() {
221 uint8_t *buf = buffer->getBufferStart();
222 parallelForEach(R&: outputSections, Fn: [buf](OutputSection *s) {
223 assert(s->isNeeded());
224 s->writeTo(buf);
225 });
226}
227
228// Computes a hash value of Data using a given hash function.
229// In order to utilize multiple cores, we first split data into 1MB
230// chunks, compute a hash for each chunk, and then compute a hash value
231// of the hash values.
232
233static void
234computeHash(llvm::MutableArrayRef<uint8_t> hashBuf,
235 llvm::ArrayRef<uint8_t> data,
236 std::function<void(uint8_t *dest, ArrayRef<uint8_t> arr)> hashFn) {
237 std::vector<ArrayRef<uint8_t>> chunks = split(arr: data, chunkSize: 1024 * 1024);
238 std::vector<uint8_t> hashes(chunks.size() * hashBuf.size());
239
240 // Compute hash values.
241 parallelFor(Begin: 0, End: chunks.size(), Fn: [&](size_t i) {
242 hashFn(hashes.data() + i * hashBuf.size(), chunks[i]);
243 });
244
245 // Write to the final output buffer.
246 hashFn(hashBuf.data(), hashes);
247}
248
249static void makeUUID(unsigned version, llvm::ArrayRef<uint8_t> fileHash,
250 llvm::MutableArrayRef<uint8_t> output) {
251 assert((version == 4 || version == 5) && "Unknown UUID version");
252 assert(output.size() == 16 && "Wrong size for UUID output");
253 if (version == 5) {
254 // Build a valid v5 UUID from a hardcoded (randomly-generated) namespace
255 // UUID, and the computed hash of the output.
256 std::array<uint8_t, 16> namespaceUUID{0xA1, 0xFA, 0x48, 0x2D, 0x0E, 0x22,
257 0x03, 0x8D, 0x33, 0x8B, 0x52, 0x1C,
258 0xD6, 0xD2, 0x12, 0xB2};
259 SHA1 sha;
260 sha.update(Data: namespaceUUID);
261 sha.update(Data: fileHash);
262 auto s = sha.final();
263 std::copy(first: s.data(), last: &s.data()[output.size()], result: output.data());
264 } else if (version == 4) {
265 if (auto ec = llvm::getRandomBytes(Buffer: output.data(), Size: output.size()))
266 error(msg: "entropy source failure: " + ec.message());
267 }
268 // Set the UUID version and variant fields.
269 // The version is the upper nibble of byte 6 (0b0101xxxx or 0b0100xxxx)
270 output[6] = (static_cast<uint8_t>(version) << 4) | (output[6] & 0xF);
271
272 // The variant is DCE 1.1/ISO 11578 (0b10xxxxxx)
273 output[8] &= 0xBF;
274 output[8] |= 0x80;
275}
276
277void Writer::writeBuildId() {
278 if (!out.buildIdSec->isNeeded())
279 return;
280 if (ctx.arg.buildId == BuildIdKind::Hexstring) {
281 out.buildIdSec->writeBuildId(buf: ctx.arg.buildIdVector);
282 return;
283 }
284
285 // Compute a hash of all sections of the output file.
286 size_t hashSize = out.buildIdSec->hashSize;
287 std::vector<uint8_t> buildId(hashSize);
288 llvm::ArrayRef<uint8_t> buf{buffer->getBufferStart(), size_t(fileSize)};
289
290 switch (ctx.arg.buildId) {
291 case BuildIdKind::Fast: {
292 std::vector<uint8_t> fileHash(8);
293 computeHash(hashBuf: fileHash, data: buf, hashFn: [](uint8_t *dest, ArrayRef<uint8_t> arr) {
294 support::endian::write64le(P: dest, V: xxh3_64bits(data: arr));
295 });
296 makeUUID(version: 5, fileHash, output: buildId);
297 break;
298 }
299 case BuildIdKind::Sha1:
300 computeHash(hashBuf: buildId, data: buf, hashFn: [&](uint8_t *dest, ArrayRef<uint8_t> arr) {
301 memcpy(dest: dest, src: SHA1::hash(Data: arr).data(), n: hashSize);
302 });
303 break;
304 case BuildIdKind::Uuid:
305 makeUUID(version: 4, fileHash: {}, output: buildId);
306 break;
307 default:
308 llvm_unreachable("unknown BuildIdKind");
309 }
310 out.buildIdSec->writeBuildId(buf: buildId);
311}
312
313static void setGlobalPtr(DefinedGlobal *g, uint64_t memoryPtr) {
314 LLVM_DEBUG(dbgs() << "setGlobalPtr " << g->getName() << " -> " << memoryPtr << "\n");
315 g->global->setPointerValue(memoryPtr);
316}
317
318static void checkPageAligned(StringRef name, uint64_t value) {
319 if (value != alignTo(Value: value, Align: ctx.arg.pageSize))
320 error(msg: name + " must be aligned to the page size (" +
321 Twine(ctx.arg.pageSize) + " bytes)");
322}
323
324// Fix the memory layout of the output binary. This assigns memory offsets
325// to each of the input data sections as well as the explicit stack region.
326// The default memory layout is as follows, from low to high.
327//
328// - initialized data (starting at ctx.arg.globalBase)
329// - BSS data (not currently implemented in llvm)
330// - explicit stack (ctx.arg.ZStackSize)
331// - heap start / unallocated
332//
333// The --stack-first option means that stack is placed before any static data.
334// This can be useful since it means that stack overflow traps immediately
335// rather than overwriting global data, but also increases code size since all
336// static data loads and stores requires larger offsets.
337void Writer::layoutMemory() {
338 uint64_t memoryPtr = 0;
339
340 auto placeStack = [&]() {
341 if (ctx.arg.relocatable || ctx.isPic)
342 return;
343 memoryPtr = alignTo(Value: memoryPtr, Align: stackAlignment);
344 if (ctx.sym.stackLow)
345 ctx.sym.stackLow->setVA(memoryPtr);
346 if (ctx.arg.zStackSize != alignTo(Value: ctx.arg.zStackSize, Align: stackAlignment))
347 error(msg: "stack size must be " + Twine(stackAlignment) + "-byte aligned");
348 log(msg: "mem: stack size = " + Twine(ctx.arg.zStackSize));
349 log(msg: "mem: stack base = " + Twine(memoryPtr));
350 memoryPtr += ctx.arg.zStackSize;
351 setGlobalPtr(g: cast<DefinedGlobal>(Val: ctx.sym.stackPointer), memoryPtr);
352 if (ctx.sym.stackHigh)
353 ctx.sym.stackHigh->setVA(memoryPtr);
354 log(msg: "mem: stack top = " + Twine(memoryPtr));
355 };
356
357 if (ctx.arg.stackFirst) {
358 placeStack();
359 if (ctx.arg.globalBase) {
360 if (ctx.arg.globalBase < memoryPtr) {
361 error(msg: "--global-base cannot be less than stack size when --stack-first is used");
362 return;
363 }
364 memoryPtr = ctx.arg.globalBase;
365 }
366 } else {
367 memoryPtr = ctx.arg.globalBase;
368 }
369
370 log(msg: "mem: global base = " + Twine(memoryPtr));
371 if (ctx.sym.globalBase)
372 ctx.sym.globalBase->setVA(memoryPtr);
373
374 uint64_t dataStart = memoryPtr;
375
376 // Arbitrarily set __dso_handle handle to point to the start of the data
377 // segments.
378 if (ctx.sym.dsoHandle)
379 ctx.sym.dsoHandle->setVA(dataStart);
380
381 out.dylinkSec->memAlign = 0;
382 for (OutputSegment *seg : segments) {
383 out.dylinkSec->memAlign = std::max(a: out.dylinkSec->memAlign, b: seg->alignment);
384 memoryPtr = alignTo(Value: memoryPtr, Align: 1ULL << seg->alignment);
385 seg->startVA = memoryPtr;
386 log(msg: formatv(Fmt: "mem: {0,-15} offset={1,-8} size={2,-8} align={3}", Vals&: seg->name,
387 Vals&: memoryPtr, Vals&: seg->size, Vals&: seg->alignment));
388
389 if (!ctx.arg.relocatable && seg->isTLS()) {
390 if (ctx.sym.tlsSize) {
391 auto *tlsSize = cast<DefinedGlobal>(Val: ctx.sym.tlsSize);
392 setGlobalPtr(g: tlsSize, memoryPtr: seg->size);
393 }
394 if (ctx.sym.tlsAlign) {
395 auto *tlsAlign = cast<DefinedGlobal>(Val: ctx.sym.tlsAlign);
396 setGlobalPtr(g: tlsAlign, memoryPtr: int64_t{1} << seg->alignment);
397 }
398 if (!ctx.arg.sharedMemory && ctx.sym.tlsBase) {
399 auto *tlsBase = cast<DefinedGlobal>(Val: ctx.sym.tlsBase);
400 setGlobalPtr(g: tlsBase, memoryPtr);
401 }
402 }
403
404 memoryPtr += seg->size;
405 }
406
407 // Make space for the memory initialization flag
408 if (ctx.arg.sharedMemory && hasPassiveInitializedSegments()) {
409 memoryPtr = alignTo(Value: memoryPtr, Align: 4);
410 ctx.sym.initMemoryFlag = symtab->addSyntheticDataSymbol(
411 name: "__wasm_init_memory_flag", flags: WASM_SYMBOL_VISIBILITY_HIDDEN);
412 ctx.sym.initMemoryFlag->markLive();
413 ctx.sym.initMemoryFlag->setVA(memoryPtr);
414 log(msg: formatv(Fmt: "mem: {0,-15} offset={1,-8} size={2,-8} align={3}",
415 Vals: "__wasm_init_memory_flag", Vals&: memoryPtr, Vals: 4, Vals: 4));
416 memoryPtr += 4;
417 }
418
419 if (ctx.sym.dataEnd)
420 ctx.sym.dataEnd->setVA(memoryPtr);
421
422 uint64_t staticDataSize = memoryPtr - dataStart;
423 log(msg: "mem: static data = " + Twine(staticDataSize));
424 if (ctx.isPic)
425 out.dylinkSec->memSize = staticDataSize;
426
427 if (!ctx.arg.stackFirst)
428 placeStack();
429
430 if (ctx.sym.heapBase) {
431 // Set `__heap_base` to follow the end of the stack or global data. The
432 // fact that this comes last means that a malloc/brk implementation can
433 // grow the heap at runtime.
434 // We'll align the heap base here because memory allocators might expect
435 // __heap_base to be aligned already.
436 memoryPtr = alignTo(Value: memoryPtr, Align: heapAlignment);
437 log(msg: "mem: heap base = " + Twine(memoryPtr));
438 ctx.sym.heapBase->setVA(memoryPtr);
439 }
440
441 uint64_t maxMemorySetting = 1ULL << 32;
442 if (ctx.arg.is64.value_or(u: false)) {
443 // TODO: Update once we decide on a reasonable limit here:
444 // https://github.com/WebAssembly/memory64/issues/33
445 maxMemorySetting = 1ULL << 34;
446 }
447
448 if (ctx.arg.initialHeap != 0) {
449 checkPageAligned(name: "initial heap", value: ctx.arg.initialHeap);
450 uint64_t maxInitialHeap = maxMemorySetting - memoryPtr;
451 if (ctx.arg.initialHeap > maxInitialHeap)
452 error(msg: "initial heap too large, cannot be greater than " +
453 Twine(maxInitialHeap));
454 memoryPtr += ctx.arg.initialHeap;
455 }
456
457 if (ctx.arg.initialMemory != 0) {
458 checkPageAligned(name: "initial memory", value: ctx.arg.initialMemory);
459 if (memoryPtr > ctx.arg.initialMemory)
460 error(msg: "initial memory too small, " + Twine(memoryPtr) + " bytes needed");
461 if (ctx.arg.initialMemory > maxMemorySetting)
462 error(msg: "initial memory too large, cannot be greater than " +
463 Twine(maxMemorySetting));
464 memoryPtr = ctx.arg.initialMemory;
465 }
466
467 memoryPtr = alignTo(Value: memoryPtr, Align: ctx.arg.pageSize);
468
469 out.memorySec->numMemoryPages = memoryPtr / ctx.arg.pageSize;
470 log(msg: "mem: total pages = " + Twine(out.memorySec->numMemoryPages));
471
472 if (ctx.sym.heapEnd) {
473 // Set `__heap_end` to follow the end of the statically allocated linear
474 // memory. The fact that this comes last means that a malloc/brk
475 // implementation can grow the heap at runtime.
476 log(msg: "mem: heap end = " + Twine(memoryPtr));
477 ctx.sym.heapEnd->setVA(memoryPtr);
478 }
479
480 uint64_t maxMemory = 0;
481 if (ctx.arg.maxMemory != 0) {
482 checkPageAligned(name: "maximum memory", value: ctx.arg.maxMemory);
483 if (memoryPtr > ctx.arg.maxMemory)
484 error(msg: "maximum memory too small, " + Twine(memoryPtr) + " bytes needed");
485 if (ctx.arg.maxMemory > maxMemorySetting)
486 error(msg: "maximum memory too large, cannot be greater than " +
487 Twine(maxMemorySetting));
488
489 maxMemory = ctx.arg.maxMemory;
490 } else if (ctx.arg.noGrowableMemory) {
491 maxMemory = memoryPtr;
492 }
493
494 // If no maxMemory config was supplied but we are building with
495 // shared memory, we need to pick a sensible upper limit.
496 if (ctx.arg.sharedMemory && maxMemory == 0) {
497 if (ctx.isPic)
498 maxMemory = maxMemorySetting;
499 else
500 maxMemory = memoryPtr;
501 }
502
503 if (maxMemory != 0) {
504 out.memorySec->maxMemoryPages = maxMemory / ctx.arg.pageSize;
505 log(msg: "mem: max pages = " + Twine(out.memorySec->maxMemoryPages));
506 }
507}
508
509void Writer::addSection(OutputSection *sec) {
510 if (!sec->isNeeded())
511 return;
512 log(msg: "addSection: " + toString(section: *sec));
513 sec->sectionIndex = outputSections.size();
514 outputSections.push_back(x: sec);
515}
516
517// If a section name is valid as a C identifier (which is rare because of
518// the leading '.'), linkers are expected to define __start_<secname> and
519// __stop_<secname> symbols. They are at beginning and end of the section,
520// respectively. This is not requested by the ELF standard, but GNU ld and
521// gold provide the feature, and used by many programs.
522static void addStartStopSymbols(const OutputSegment *seg) {
523 StringRef name = seg->name;
524 if (!isValidCIdentifier(s: name))
525 return;
526 LLVM_DEBUG(dbgs() << "addStartStopSymbols: " << name << "\n");
527 uint64_t start = seg->startVA;
528 uint64_t stop = start + seg->size;
529 symtab->addOptionalDataSymbol(name: saver().save(S: "__start_" + name), value: start);
530 symtab->addOptionalDataSymbol(name: saver().save(S: "__stop_" + name), value: stop);
531}
532
533void Writer::addSections() {
534 addSection(sec: out.dylinkSec);
535 addSection(sec: out.typeSec);
536 addSection(sec: out.importSec);
537 addSection(sec: out.functionSec);
538 addSection(sec: out.tableSec);
539 addSection(sec: out.memorySec);
540 addSection(sec: out.tagSec);
541 addSection(sec: out.globalSec);
542 addSection(sec: out.exportSec);
543 addSection(sec: out.startSec);
544 addSection(sec: out.elemSec);
545 addSection(sec: out.dataCountSec);
546
547 addSection(sec: make<CodeSection>(args&: out.functionSec->inputFunctions));
548 addSection(sec: make<DataSection>(args&: segments));
549
550 createCustomSections();
551
552 addSection(sec: out.linkingSec);
553 if (ctx.arg.emitRelocs || ctx.arg.relocatable) {
554 createRelocSections();
555 }
556
557 addSection(sec: out.nameSec);
558 addSection(sec: out.producersSec);
559 addSection(sec: out.targetFeaturesSec);
560 addSection(sec: out.buildIdSec);
561}
562
563void Writer::finalizeSections() {
564 for (OutputSection *s : outputSections) {
565 s->setOffset(fileSize);
566 s->finalizeContents();
567 fileSize += s->getSize();
568 }
569}
570
571void Writer::populateTargetFeatures() {
572 StringMap<std::string> used;
573 StringMap<std::string> disallowed;
574 SmallSet<std::string, 8> &allowed = out.targetFeaturesSec->features;
575 bool tlsUsed = false;
576
577 if (ctx.isPic) {
578 // This should not be necessary because all PIC objects should
579 // contain the mutable-globals feature.
580 // TODO (https://github.com/llvm/llvm-project/issues/51681)
581 allowed.insert(V: "mutable-globals");
582 }
583
584 if (ctx.arg.extraFeatures.has_value()) {
585 auto &extraFeatures = *ctx.arg.extraFeatures;
586 allowed.insert_range(R&: extraFeatures);
587 }
588
589 // Only infer used features if user did not specify features
590 bool inferFeatures = !ctx.arg.features.has_value();
591
592 if (!inferFeatures) {
593 auto &explicitFeatures = *ctx.arg.features;
594 allowed.insert_range(R&: explicitFeatures);
595 if (!ctx.arg.checkFeatures)
596 goto done;
597 }
598
599 // Find the sets of used and disallowed features
600 for (ObjFile *file : ctx.objectFiles) {
601 StringRef fileName(file->getName());
602 for (auto &feature : file->getWasmObj()->getTargetFeatures()) {
603 switch (feature.Prefix) {
604 case WASM_FEATURE_PREFIX_USED:
605 used.insert(KV: {feature.Name, std::string(fileName)});
606 break;
607 case WASM_FEATURE_PREFIX_DISALLOWED:
608 disallowed.insert(KV: {feature.Name, std::string(fileName)});
609 break;
610 default:
611 error(msg: "Unrecognized feature policy prefix " +
612 std::to_string(val: feature.Prefix));
613 }
614 }
615
616 // Find TLS data segments
617 auto isTLS = [](InputChunk *segment) {
618 return segment->live && segment->isTLS();
619 };
620 tlsUsed = tlsUsed || llvm::any_of(Range&: file->segments, P: isTLS);
621 }
622
623 if (inferFeatures)
624 for (const auto &key : used.keys())
625 allowed.insert(V: std::string(key));
626
627 if (!ctx.arg.checkFeatures)
628 goto done;
629
630 if (ctx.arg.sharedMemory) {
631 if (disallowed.count(Key: "shared-mem"))
632 error(msg: "--shared-memory is disallowed by " + disallowed["shared-mem"] +
633 " because it was not compiled with 'atomics' or 'bulk-memory' "
634 "features.");
635
636 for (auto feature : {"atomics", "bulk-memory"})
637 if (!allowed.count(V: feature))
638 error(msg: StringRef("'") + feature +
639 "' feature must be used in order to use shared memory");
640 }
641
642 if (tlsUsed) {
643 for (auto feature : {"atomics", "bulk-memory"})
644 if (!allowed.count(V: feature))
645 error(msg: StringRef("'") + feature +
646 "' feature must be used in order to use thread-local storage");
647 }
648
649 // Validate that used features are allowed in output
650 if (!inferFeatures) {
651 for (const auto &feature : used.keys()) {
652 if (!allowed.count(V: std::string(feature)))
653 error(msg: Twine("Target feature '") + feature + "' used by " +
654 used[feature] + " is not allowed.");
655 }
656 }
657
658 // Validate the disallowed constraints for each file
659 for (ObjFile *file : ctx.objectFiles) {
660 StringRef fileName(file->getName());
661 SmallSet<std::string, 8> objectFeatures;
662 for (const auto &feature : file->getWasmObj()->getTargetFeatures()) {
663 if (feature.Prefix == WASM_FEATURE_PREFIX_DISALLOWED)
664 continue;
665 objectFeatures.insert(V: feature.Name);
666 if (disallowed.count(Key: feature.Name))
667 error(msg: Twine("Target feature '") + feature.Name + "' used in " +
668 fileName + " is disallowed by " + disallowed[feature.Name] +
669 ". Use --no-check-features to suppress.");
670 }
671 }
672
673done:
674 // Normally we don't include bss segments in the binary. In particular if
675 // memory is not being imported then we can assume its zero initialized.
676 // In the case the memory is imported, and we can use the memory.fill
677 // instruction, then we can also avoid including the segments.
678 // Finally, if we are emitting relocations, they may refer to locations within
679 // the bss segments, so these segments need to exist in the binary.
680 if (ctx.arg.emitRelocs ||
681 (ctx.arg.memoryImport.has_value() && !allowed.count(V: "bulk-memory")))
682 ctx.emitBssSegments = true;
683
684 if (allowed.count(V: "extended-const"))
685 ctx.arg.extendedConst = true;
686
687 for (auto &feature : allowed)
688 log(msg: "Allowed feature: " + feature);
689}
690
691void Writer::checkImportExportTargetFeatures() {
692 if (ctx.arg.relocatable || !ctx.arg.checkFeatures)
693 return;
694
695 if (out.targetFeaturesSec->features.count(V: "mutable-globals") == 0) {
696 for (const Symbol *sym : out.importSec->importedSymbols) {
697 if (auto *global = dyn_cast<GlobalSymbol>(Val: sym)) {
698 if (global->getGlobalType()->Mutable) {
699 error(msg: Twine("mutable global imported but 'mutable-globals' feature "
700 "not present in inputs: `") +
701 toString(sym: *sym) + "`. Use --no-check-features to suppress.");
702 }
703 }
704 }
705 for (const Symbol *sym : out.exportSec->exportedSymbols) {
706 if (isa<GlobalSymbol>(Val: sym)) {
707 error(msg: Twine("mutable global exported but 'mutable-globals' feature "
708 "not present in inputs: `") +
709 toString(sym: *sym) + "`. Use --no-check-features to suppress.");
710 }
711 }
712 }
713}
714
715static bool shouldImport(Symbol *sym) {
716 // We don't generate imports for data symbols. They however can be imported
717 // as GOT entries.
718 if (isa<DataSymbol>(Val: sym))
719 return false;
720 if (!sym->isLive())
721 return false;
722 if (!sym->isUsedInRegularObj)
723 return false;
724
725 // When a symbol is weakly defined in a shared library we need to allow
726 // it to be overridden by another module so need to both import
727 // and export the symbol.
728 if (ctx.arg.shared && sym->isWeak() && !sym->isUndefined() &&
729 !sym->isHidden())
730 return true;
731 if (sym->isShared())
732 return true;
733 if (!sym->isUndefined())
734 return false;
735 if (sym->isWeak() && !ctx.arg.relocatable && !ctx.isPic)
736 return false;
737
738 // In PIC mode we only need to import functions when they are called directly.
739 // Indirect usage all goes via GOT imports.
740 if (ctx.isPic) {
741 if (auto *f = dyn_cast<UndefinedFunction>(Val: sym))
742 if (!f->isCalledDirectly)
743 return false;
744 }
745
746 if (ctx.isPic || ctx.arg.relocatable || ctx.arg.importUndefined ||
747 ctx.arg.unresolvedSymbols == UnresolvedPolicy::ImportDynamic)
748 return true;
749 if (ctx.arg.allowUndefinedSymbols.count(Key: sym->getName()) != 0)
750 return true;
751
752 return sym->isImported();
753}
754
755void Writer::calculateImports() {
756 // Some inputs require that the indirect function table be assigned to table
757 // number 0, so if it is present and is an import, allocate it before any
758 // other tables.
759 if (ctx.sym.indirectFunctionTable &&
760 shouldImport(sym: ctx.sym.indirectFunctionTable))
761 out.importSec->addImport(sym: ctx.sym.indirectFunctionTable);
762
763 for (Symbol *sym : symtab->symbols()) {
764 if (!shouldImport(sym))
765 continue;
766 if (sym == ctx.sym.indirectFunctionTable)
767 continue;
768 LLVM_DEBUG(dbgs() << "import: " << sym->getName() << "\n");
769 out.importSec->addImport(sym);
770 }
771}
772
773void Writer::calculateExports() {
774 if (ctx.arg.relocatable)
775 return;
776
777 if (!ctx.arg.relocatable && ctx.arg.memoryExport.has_value()) {
778 out.exportSec->exports.push_back(
779 x: WasmExport{.Name: *ctx.arg.memoryExport, .Kind: WASM_EXTERNAL_MEMORY, .Index: 0});
780 }
781
782 unsigned globalIndex =
783 out.importSec->getNumImportedGlobals() + out.globalSec->numGlobals();
784
785 for (Symbol *sym : symtab->symbols()) {
786 if (!sym->isExported())
787 continue;
788 if (!sym->isLive())
789 continue;
790 if (isa<SharedFunctionSymbol>(Val: sym) || sym->isShared())
791 continue;
792
793 StringRef name = sym->getName();
794 LLVM_DEBUG(dbgs() << "Export: " << name << "\n");
795 WasmExport export_;
796 if (auto *f = dyn_cast<DefinedFunction>(Val: sym)) {
797 if (std::optional<StringRef> exportName = f->function->getExportName()) {
798 name = *exportName;
799 }
800 export_ = {.Name: name, .Kind: WASM_EXTERNAL_FUNCTION, .Index: f->getExportedFunctionIndex()};
801 } else if (auto *g = dyn_cast<DefinedGlobal>(Val: sym)) {
802 if (g->getGlobalType()->Mutable && !g->getFile() && !g->forceExport) {
803 // Avoid exporting mutable globals are linker synthesized (e.g.
804 // __stack_pointer or __tls_base) unless they are explicitly exported
805 // from the command line.
806 // Without this check `--export-all` would cause any program using the
807 // stack pointer to export a mutable global even if none of the input
808 // files were built with the `mutable-globals` feature.
809 continue;
810 }
811 export_ = {.Name: name, .Kind: WASM_EXTERNAL_GLOBAL, .Index: g->getGlobalIndex()};
812 } else if (auto *t = dyn_cast<DefinedTag>(Val: sym)) {
813 export_ = {.Name: name, .Kind: WASM_EXTERNAL_TAG, .Index: t->getTagIndex()};
814 } else if (auto *d = dyn_cast<DefinedData>(Val: sym)) {
815 out.globalSec->dataAddressGlobals.push_back(x: d);
816 export_ = {.Name: name, .Kind: WASM_EXTERNAL_GLOBAL, .Index: globalIndex++};
817 } else {
818 auto *t = cast<DefinedTable>(Val: sym);
819 export_ = {.Name: name, .Kind: WASM_EXTERNAL_TABLE, .Index: t->getTableNumber()};
820 }
821
822 out.exportSec->exports.push_back(x: export_);
823 out.exportSec->exportedSymbols.push_back(x: sym);
824 }
825}
826
827void Writer::populateSymtab() {
828 if (!ctx.arg.relocatable && !ctx.arg.emitRelocs)
829 return;
830
831 for (Symbol *sym : symtab->symbols())
832 if (sym->isUsedInRegularObj && sym->isLive() && !sym->isShared())
833 out.linkingSec->addToSymtab(sym);
834
835 for (ObjFile *file : ctx.objectFiles) {
836 LLVM_DEBUG(dbgs() << "Local symtab entries: " << file->getName() << "\n");
837 for (Symbol *sym : file->getSymbols())
838 if (sym->isLocal() && !isa<SectionSymbol>(Val: sym) && sym->isLive())
839 out.linkingSec->addToSymtab(sym);
840 }
841}
842
843void Writer::calculateTypes() {
844 // The output type section is the union of the following sets:
845 // 1. Any signature used in the TYPE relocation
846 // 2. The signatures of all imported functions
847 // 3. The signatures of all defined functions
848 // 4. The signatures of all imported tags
849 // 5. The signatures of all defined tags
850
851 for (ObjFile *file : ctx.objectFiles) {
852 ArrayRef<WasmSignature> types = file->getWasmObj()->types();
853 for (uint32_t i = 0; i < types.size(); i++)
854 if (file->typeIsUsed[i])
855 file->typeMap[i] = out.typeSec->registerType(sig: types[i]);
856 }
857
858 for (const Symbol *sym : out.importSec->importedSymbols) {
859 if (auto *f = dyn_cast<FunctionSymbol>(Val: sym))
860 out.typeSec->registerType(sig: *f->signature);
861 else if (auto *t = dyn_cast<TagSymbol>(Val: sym))
862 out.typeSec->registerType(sig: *t->signature);
863 }
864
865 for (const InputFunction *f : out.functionSec->inputFunctions)
866 out.typeSec->registerType(sig: f->signature);
867
868 for (const InputTag *t : out.tagSec->inputTags)
869 out.typeSec->registerType(sig: t->signature);
870}
871
872// In a command-style link, create a wrapper for each exported symbol
873// which calls the constructors and destructors.
874void Writer::createCommandExportWrappers() {
875 // This logic doesn't currently support Emscripten-style PIC mode.
876 assert(!ctx.isPic);
877
878 // If there are no ctors and there's no libc `__wasm_call_dtors` to
879 // call, don't wrap the exports.
880 if (initFunctions.empty() && ctx.sym.callDtors == nullptr)
881 return;
882
883 std::vector<DefinedFunction *> toWrap;
884
885 for (Symbol *sym : symtab->symbols())
886 if (sym->isExported())
887 if (auto *f = dyn_cast<DefinedFunction>(Val: sym))
888 toWrap.push_back(x: f);
889
890 for (auto *f : toWrap) {
891 auto funcNameStr = (f->getName() + ".command_export").str();
892 commandExportWrapperNames.push_back(x: funcNameStr);
893 const std::string &funcName = commandExportWrapperNames.back();
894
895 auto func = make<SyntheticFunction>(args: *f->getSignature(), args: funcName);
896 if (f->function->getExportName())
897 func->setExportName(f->function->getExportName()->str());
898 else
899 func->setExportName(f->getName().str());
900
901 DefinedFunction *def =
902 symtab->addSyntheticFunction(name: funcName, flags: f->flags, function: func);
903 def->markLive();
904
905 def->flags |= WASM_SYMBOL_EXPORTED;
906 def->flags &= ~WASM_SYMBOL_VISIBILITY_HIDDEN;
907 def->forceExport = f->forceExport;
908
909 f->flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
910 f->flags &= ~WASM_SYMBOL_EXPORTED;
911 f->forceExport = false;
912
913 out.functionSec->addFunction(func);
914
915 createCommandExportWrapper(functionIndex: f->getFunctionIndex(), f: def);
916 }
917}
918
919static void finalizeIndirectFunctionTable() {
920 if (!ctx.sym.indirectFunctionTable)
921 return;
922
923 if (shouldImport(sym: ctx.sym.indirectFunctionTable) &&
924 !ctx.sym.indirectFunctionTable->hasTableNumber()) {
925 // Processing -Bsymbolic relocations resulted in a late requirement that the
926 // indirect function table be present, and we are running in --import-table
927 // mode. Add the table now to the imports section. Otherwise it will be
928 // added to the tables section later in assignIndexes.
929 out.importSec->addImport(sym: ctx.sym.indirectFunctionTable);
930 }
931
932 uint32_t tableSize = ctx.arg.tableBase + out.elemSec->numEntries();
933 WasmLimits limits = {.Flags: 0, .Minimum: tableSize, .Maximum: 0, .PageSize: 0};
934 if (ctx.sym.indirectFunctionTable->isDefined() && !ctx.arg.growableTable) {
935 limits.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
936 limits.Maximum = limits.Minimum;
937 }
938 if (ctx.arg.is64.value_or(u: false))
939 limits.Flags |= WASM_LIMITS_FLAG_IS_64;
940 ctx.sym.indirectFunctionTable->setLimits(limits);
941}
942
943static void scanRelocations() {
944 for (ObjFile *file : ctx.objectFiles) {
945 LLVM_DEBUG(dbgs() << "scanRelocations: " << file->getName() << "\n");
946 for (InputChunk *chunk : file->functions)
947 scanRelocations(chunk);
948 for (InputChunk *chunk : file->segments)
949 scanRelocations(chunk);
950 for (auto &p : file->customSections)
951 scanRelocations(chunk: p);
952 }
953}
954
955void Writer::assignIndexes() {
956 // Seal the import section, since other index spaces such as function and
957 // global are effected by the number of imports.
958 out.importSec->seal();
959
960 for (InputFunction *func : ctx.syntheticFunctions)
961 out.functionSec->addFunction(func);
962
963 for (ObjFile *file : ctx.objectFiles) {
964 LLVM_DEBUG(dbgs() << "Functions: " << file->getName() << "\n");
965 for (InputFunction *func : file->functions)
966 out.functionSec->addFunction(func);
967 }
968
969 for (InputGlobal *global : ctx.syntheticGlobals)
970 out.globalSec->addGlobal(global);
971
972 for (ObjFile *file : ctx.objectFiles) {
973 LLVM_DEBUG(dbgs() << "Globals: " << file->getName() << "\n");
974 for (InputGlobal *global : file->globals)
975 out.globalSec->addGlobal(global);
976 }
977
978 for (ObjFile *file : ctx.objectFiles) {
979 LLVM_DEBUG(dbgs() << "Tags: " << file->getName() << "\n");
980 for (InputTag *tag : file->tags)
981 out.tagSec->addTag(tag);
982 }
983
984 for (ObjFile *file : ctx.objectFiles) {
985 LLVM_DEBUG(dbgs() << "Tables: " << file->getName() << "\n");
986 for (InputTable *table : file->tables)
987 out.tableSec->addTable(table);
988 }
989
990 for (InputTable *table : ctx.syntheticTables)
991 out.tableSec->addTable(table);
992
993 out.globalSec->assignIndexes();
994 out.tableSec->assignIndexes();
995}
996
997static StringRef getOutputDataSegmentName(const InputChunk &seg) {
998 // We always merge .tbss and .tdata into a single TLS segment so all TLS
999 // symbols are be relative to single __tls_base.
1000 if (seg.isTLS())
1001 return ".tdata";
1002 if (!ctx.arg.mergeDataSegments)
1003 return seg.name;
1004 if (seg.name.starts_with(Prefix: ".text."))
1005 return ".text";
1006 if (seg.name.starts_with(Prefix: ".data."))
1007 return ".data";
1008 if (seg.name.starts_with(Prefix: ".bss."))
1009 return ".bss";
1010 if (seg.name.starts_with(Prefix: ".rodata."))
1011 return ".rodata";
1012 return seg.name;
1013}
1014
1015OutputSegment *Writer::createOutputSegment(StringRef name) {
1016 LLVM_DEBUG(dbgs() << "new segment: " << name << "\n");
1017 OutputSegment *s = make<OutputSegment>(args&: name);
1018 if (ctx.arg.sharedMemory)
1019 s->initFlags = WASM_DATA_SEGMENT_IS_PASSIVE;
1020 if (!ctx.arg.relocatable && name.starts_with(Prefix: ".bss"))
1021 s->isBss = true;
1022 segments.push_back(x: s);
1023 return s;
1024}
1025
1026void Writer::createOutputSegments() {
1027 for (ObjFile *file : ctx.objectFiles) {
1028 for (InputChunk *segment : file->segments) {
1029 if (!segment->live)
1030 continue;
1031 StringRef name = getOutputDataSegmentName(seg: *segment);
1032 OutputSegment *s = nullptr;
1033 // When running in relocatable mode we can't merge segments that are part
1034 // of comdat groups since the ultimate linker needs to be able exclude or
1035 // include them individually.
1036 if (ctx.arg.relocatable && !segment->getComdatName().empty()) {
1037 s = createOutputSegment(name);
1038 } else {
1039 if (segmentMap.count(Val: name) == 0)
1040 segmentMap[name] = createOutputSegment(name);
1041 s = segmentMap[name];
1042 }
1043 s->addInputSegment(inSeg: segment);
1044 }
1045 }
1046
1047 // Sort segments by type, placing .bss last
1048 llvm::stable_sort(Range&: segments,
1049 C: [](const OutputSegment *a, const OutputSegment *b) {
1050 auto order = [](StringRef name) {
1051 return StringSwitch<int>(name)
1052 .StartsWith(S: ".tdata", Value: 0)
1053 .StartsWith(S: ".rodata", Value: 1)
1054 .StartsWith(S: ".data", Value: 2)
1055 .StartsWith(S: ".bss", Value: 4)
1056 .Default(Value: 3);
1057 };
1058 return order(a->name) < order(b->name);
1059 });
1060
1061 for (size_t i = 0; i < segments.size(); ++i)
1062 segments[i]->index = i;
1063
1064 // Merge MergeInputSections into a single MergeSyntheticSection.
1065 LLVM_DEBUG(dbgs() << "-- finalize input semgments\n");
1066 for (OutputSegment *seg : segments)
1067 seg->finalizeInputSegments();
1068}
1069
1070void Writer::combineOutputSegments() {
1071 // With PIC code we currently only support a single active data segment since
1072 // we only have a single __memory_base to use as our base address. This pass
1073 // combines all data segments into a single .data segment.
1074 // This restriction does not apply when the extended const extension is
1075 // available: https://github.com/WebAssembly/extended-const
1076 assert(!ctx.arg.extendedConst);
1077 assert(ctx.isPic && !ctx.arg.sharedMemory);
1078 if (segments.size() <= 1)
1079 return;
1080 OutputSegment *combined = make<OutputSegment>(args: ".data");
1081 combined->startVA = segments[0]->startVA;
1082 std::vector<OutputSegment *> newSegments = {combined};
1083 for (OutputSegment *s : segments) {
1084 if (!s->requiredInBinary()) {
1085 newSegments.push_back(x: s);
1086 continue;
1087 }
1088 bool first = true;
1089 for (InputChunk *inSeg : s->inputSegments) {
1090 if (first)
1091 inSeg->alignment = std::max(a: inSeg->alignment, b: s->alignment);
1092 first = false;
1093#ifndef NDEBUG
1094 uint64_t oldVA = inSeg->getVA();
1095#endif
1096 combined->addInputSegment(inSeg);
1097#ifndef NDEBUG
1098 uint64_t newVA = inSeg->getVA();
1099 LLVM_DEBUG(dbgs() << "added input segment. name=" << inSeg->name
1100 << " oldVA=" << oldVA << " newVA=" << newVA << "\n");
1101 assert(oldVA == newVA);
1102#endif
1103 }
1104 }
1105
1106 segments = newSegments;
1107}
1108
1109static void createFunction(DefinedFunction *func, StringRef bodyContent) {
1110 std::string functionBody;
1111 {
1112 raw_string_ostream os(functionBody);
1113 writeUleb128(os, number: bodyContent.size(), msg: "function size");
1114 os << bodyContent;
1115 }
1116 ArrayRef<uint8_t> body = arrayRefFromStringRef(Input: saver().save(S: functionBody));
1117 cast<SyntheticFunction>(Val: func->function)->setBody(body);
1118}
1119
1120bool Writer::needsPassiveInitialization(const OutputSegment *segment) {
1121 // If bulk memory features is supported then we can perform bss initialization
1122 // (via memory.fill) during `__wasm_init_memory`.
1123 if (ctx.arg.memoryImport.has_value() && !segment->requiredInBinary())
1124 return true;
1125 return segment->initFlags & WASM_DATA_SEGMENT_IS_PASSIVE;
1126}
1127
1128bool Writer::hasPassiveInitializedSegments() {
1129 return llvm::any_of(Range&: segments, P: [this](const OutputSegment *s) {
1130 return this->needsPassiveInitialization(segment: s);
1131 });
1132}
1133
1134void Writer::createSyntheticInitFunctions() {
1135 if (ctx.arg.relocatable)
1136 return;
1137
1138 static WasmSignature nullSignature = {{}, {}};
1139
1140 createApplyDataRelocationsFunction();
1141
1142 // Passive segments are used to avoid memory being reinitialized on each
1143 // thread's instantiation. These passive segments are initialized and
1144 // dropped in __wasm_init_memory, which is registered as the start function
1145 // We also initialize bss segments (using memory.fill) as part of this
1146 // function.
1147 if (hasPassiveInitializedSegments()) {
1148 ctx.sym.initMemory = symtab->addSyntheticFunction(
1149 name: "__wasm_init_memory", flags: WASM_SYMBOL_VISIBILITY_HIDDEN,
1150 function: make<SyntheticFunction>(args&: nullSignature, args: "__wasm_init_memory"));
1151 ctx.sym.initMemory->markLive();
1152 if (ctx.arg.sharedMemory) {
1153 // This global is assigned during __wasm_init_memory in the shared memory
1154 // case.
1155 ctx.sym.tlsBase->markLive();
1156 }
1157 }
1158
1159 if (ctx.arg.sharedMemory) {
1160 if (out.globalSec->needsTLSRelocations()) {
1161 ctx.sym.applyGlobalTLSRelocs = symtab->addSyntheticFunction(
1162 name: "__wasm_apply_global_tls_relocs", flags: WASM_SYMBOL_VISIBILITY_HIDDEN,
1163 function: make<SyntheticFunction>(args&: nullSignature,
1164 args: "__wasm_apply_global_tls_relocs"));
1165 ctx.sym.applyGlobalTLSRelocs->markLive();
1166 // TLS relocations depend on the __tls_base symbols
1167 ctx.sym.tlsBase->markLive();
1168 }
1169
1170 auto hasTLSRelocs = [](const OutputSegment *segment) {
1171 if (segment->isTLS())
1172 for (const auto* is: segment->inputSegments)
1173 if (is->getRelocations().size())
1174 return true;
1175 return false;
1176 };
1177 if (llvm::any_of(Range&: segments, P: hasTLSRelocs)) {
1178 ctx.sym.applyTLSRelocs = symtab->addSyntheticFunction(
1179 name: "__wasm_apply_tls_relocs", flags: WASM_SYMBOL_VISIBILITY_HIDDEN,
1180 function: make<SyntheticFunction>(args&: nullSignature, args: "__wasm_apply_tls_relocs"));
1181 ctx.sym.applyTLSRelocs->markLive();
1182 }
1183 }
1184
1185 if (ctx.isPic && out.globalSec->needsRelocations()) {
1186 ctx.sym.applyGlobalRelocs = symtab->addSyntheticFunction(
1187 name: "__wasm_apply_global_relocs", flags: WASM_SYMBOL_VISIBILITY_HIDDEN,
1188 function: make<SyntheticFunction>(args&: nullSignature, args: "__wasm_apply_global_relocs"));
1189 ctx.sym.applyGlobalRelocs->markLive();
1190 }
1191
1192 // If there is only one start function we can just use that function
1193 // itself as the Wasm start function, otherwise we need to synthesize
1194 // a new function to call them in sequence.
1195 if (ctx.sym.applyGlobalRelocs && ctx.sym.initMemory) {
1196 ctx.sym.startFunction = symtab->addSyntheticFunction(
1197 name: "__wasm_start", flags: WASM_SYMBOL_VISIBILITY_HIDDEN,
1198 function: make<SyntheticFunction>(args&: nullSignature, args: "__wasm_start"));
1199 ctx.sym.startFunction->markLive();
1200 }
1201}
1202
1203void Writer::createInitMemoryFunction() {
1204 LLVM_DEBUG(dbgs() << "createInitMemoryFunction\n");
1205 assert(ctx.sym.initMemory);
1206 assert(hasPassiveInitializedSegments());
1207 uint64_t flagAddress;
1208 if (ctx.arg.sharedMemory) {
1209 assert(ctx.sym.initMemoryFlag);
1210 flagAddress = ctx.sym.initMemoryFlag->getVA();
1211 }
1212 bool is64 = ctx.arg.is64.value_or(u: false);
1213 std::string bodyContent;
1214 {
1215 raw_string_ostream os(bodyContent);
1216 // Initialize memory in a thread-safe manner. The thread that successfully
1217 // increments the flag from 0 to 1 is responsible for performing the memory
1218 // initialization. Other threads go sleep on the flag until the first thread
1219 // finishing initializing memory, increments the flag to 2, and wakes all
1220 // the other threads. Once the flag has been set to 2, subsequently started
1221 // threads will skip the sleep. All threads unconditionally drop their
1222 // passive data segments once memory has been initialized. The generated
1223 // code is as follows:
1224 //
1225 // (func $__wasm_init_memory
1226 // (block $drop
1227 // (block $wait
1228 // (block $init
1229 // (br_table $init $wait $drop
1230 // (i32.atomic.rmw.cmpxchg align=2 offset=0
1231 // (i32.const $__init_memory_flag)
1232 // (i32.const 0)
1233 // (i32.const 1)
1234 // )
1235 // )
1236 // ) ;; $init
1237 // ( ... initialize data segments ... )
1238 // (i32.atomic.store align=2 offset=0
1239 // (i32.const $__init_memory_flag)
1240 // (i32.const 2)
1241 // )
1242 // (drop
1243 // (i32.atomic.notify align=2 offset=0
1244 // (i32.const $__init_memory_flag)
1245 // (i32.const -1u)
1246 // )
1247 // )
1248 // (br $drop)
1249 // ) ;; $wait
1250 // (drop
1251 // (i32.atomic.wait align=2 offset=0
1252 // (i32.const $__init_memory_flag)
1253 // (i32.const 1)
1254 // (i32.const -1)
1255 // )
1256 // )
1257 // ) ;; $drop
1258 // ( ... drop data segments ... )
1259 // )
1260 //
1261 // When we are building with PIC, calculate the flag location using:
1262 //
1263 // (global.get $__memory_base)
1264 // (i32.const $__init_memory_flag)
1265 // (i32.const 1)
1266
1267 auto writeGetFlagAddress = [&]() {
1268 if (ctx.isPic) {
1269 writeU8(os, byte: WASM_OPCODE_LOCAL_GET, msg: "local.get");
1270 writeUleb128(os, number: 0, msg: "local 0");
1271 } else {
1272 writePtrConst(os, number: flagAddress, is64, msg: "flag address");
1273 }
1274 };
1275
1276 if (ctx.arg.sharedMemory) {
1277 // With PIC code we cache the flag address in local 0
1278 if (ctx.isPic) {
1279 writeUleb128(os, number: 1, msg: "num local decls");
1280 writeUleb128(os, number: 2, msg: "local count");
1281 writeU8(os, byte: is64 ? WASM_TYPE_I64 : WASM_TYPE_I32, msg: "address type");
1282 writeU8(os, byte: WASM_OPCODE_GLOBAL_GET, msg: "GLOBAL_GET");
1283 writeUleb128(os, number: ctx.sym.memoryBase->getGlobalIndex(), msg: "memory_base");
1284 writePtrConst(os, number: flagAddress, is64, msg: "flag address");
1285 writeU8(os, byte: is64 ? WASM_OPCODE_I64_ADD : WASM_OPCODE_I32_ADD, msg: "add");
1286 writeU8(os, byte: WASM_OPCODE_LOCAL_SET, msg: "local.set");
1287 writeUleb128(os, number: 0, msg: "local 0");
1288 } else {
1289 writeUleb128(os, number: 0, msg: "num locals");
1290 }
1291
1292 // Set up destination blocks
1293 writeU8(os, byte: WASM_OPCODE_BLOCK, msg: "block $drop");
1294 writeU8(os, byte: WASM_TYPE_NORESULT, msg: "block type");
1295 writeU8(os, byte: WASM_OPCODE_BLOCK, msg: "block $wait");
1296 writeU8(os, byte: WASM_TYPE_NORESULT, msg: "block type");
1297 writeU8(os, byte: WASM_OPCODE_BLOCK, msg: "block $init");
1298 writeU8(os, byte: WASM_TYPE_NORESULT, msg: "block type");
1299
1300 // Atomically check whether we win the race.
1301 writeGetFlagAddress();
1302 writeI32Const(os, number: 0, msg: "expected flag value");
1303 writeI32Const(os, number: 1, msg: "new flag value");
1304 writeU8(os, byte: WASM_OPCODE_ATOMICS_PREFIX, msg: "atomics prefix");
1305 writeUleb128(os, number: WASM_OPCODE_I32_RMW_CMPXCHG, msg: "i32.atomic.rmw.cmpxchg");
1306 writeMemArg(os, alignment: 2, offset: 0);
1307
1308 // Based on the value, decide what to do next.
1309 writeU8(os, byte: WASM_OPCODE_BR_TABLE, msg: "br_table");
1310 writeUleb128(os, number: 2, msg: "label vector length");
1311 writeUleb128(os, number: 0, msg: "label $init");
1312 writeUleb128(os, number: 1, msg: "label $wait");
1313 writeUleb128(os, number: 2, msg: "default label $drop");
1314
1315 // Initialize passive data segments
1316 writeU8(os, byte: WASM_OPCODE_END, msg: "end $init");
1317 } else {
1318 writeUleb128(os, number: 0, msg: "num local decls");
1319 }
1320
1321 for (const OutputSegment *s : segments) {
1322 if (needsPassiveInitialization(segment: s)) {
1323 // For passive BSS segments we can simple issue a memory.fill(0).
1324 // For non-BSS segments we do a memory.init. Both these
1325 // instructions take as their first argument the destination
1326 // address.
1327 writePtrConst(os, number: s->startVA, is64, msg: "destination address");
1328 if (ctx.isPic) {
1329 writeU8(os, byte: WASM_OPCODE_GLOBAL_GET, msg: "GLOBAL_GET");
1330 writeUleb128(os, number: ctx.sym.memoryBase->getGlobalIndex(),
1331 msg: "__memory_base");
1332 writeU8(os, byte: is64 ? WASM_OPCODE_I64_ADD : WASM_OPCODE_I32_ADD,
1333 msg: "i32.add");
1334 }
1335
1336 // When we initialize the TLS segment we also set the `__tls_base`
1337 // global. This allows the runtime to use this static copy of the
1338 // TLS data for the first/main thread.
1339 if (ctx.arg.sharedMemory && s->isTLS()) {
1340 if (ctx.isPic) {
1341 // Cache the result of the addionion in local 0
1342 writeU8(os, byte: WASM_OPCODE_LOCAL_TEE, msg: "local.tee");
1343 writeUleb128(os, number: 1, msg: "local 1");
1344 } else {
1345 writePtrConst(os, number: s->startVA, is64, msg: "destination address");
1346 }
1347 writeU8(os, byte: WASM_OPCODE_GLOBAL_SET, msg: "GLOBAL_SET");
1348 writeUleb128(os, number: ctx.sym.tlsBase->getGlobalIndex(), msg: "__tls_base");
1349 if (ctx.isPic) {
1350 writeU8(os, byte: WASM_OPCODE_LOCAL_GET, msg: "local.tee");
1351 writeUleb128(os, number: 1, msg: "local 1");
1352 }
1353 }
1354
1355 if (s->isBss) {
1356 writeI32Const(os, number: 0, msg: "fill value");
1357 writePtrConst(os, number: s->size, is64, msg: "memory region size");
1358 writeU8(os, byte: WASM_OPCODE_MISC_PREFIX, msg: "bulk-memory prefix");
1359 writeUleb128(os, number: WASM_OPCODE_MEMORY_FILL, msg: "memory.fill");
1360 writeU8(os, byte: 0, msg: "memory index immediate");
1361 } else {
1362 writeI32Const(os, number: 0, msg: "source segment offset");
1363 writeI32Const(os, number: s->size, msg: "memory region size");
1364 writeU8(os, byte: WASM_OPCODE_MISC_PREFIX, msg: "bulk-memory prefix");
1365 writeUleb128(os, number: WASM_OPCODE_MEMORY_INIT, msg: "memory.init");
1366 writeUleb128(os, number: s->index, msg: "segment index immediate");
1367 writeU8(os, byte: 0, msg: "memory index immediate");
1368 }
1369 }
1370 }
1371
1372 if (ctx.arg.sharedMemory) {
1373 // Set flag to 2 to mark end of initialization
1374 writeGetFlagAddress();
1375 writeI32Const(os, number: 2, msg: "flag value");
1376 writeU8(os, byte: WASM_OPCODE_ATOMICS_PREFIX, msg: "atomics prefix");
1377 writeUleb128(os, number: WASM_OPCODE_I32_ATOMIC_STORE, msg: "i32.atomic.store");
1378 writeMemArg(os, alignment: 2, offset: 0);
1379
1380 // Notify any waiters that memory initialization is complete
1381 writeGetFlagAddress();
1382 writeI32Const(os, number: -1, msg: "number of waiters");
1383 writeU8(os, byte: WASM_OPCODE_ATOMICS_PREFIX, msg: "atomics prefix");
1384 writeUleb128(os, number: WASM_OPCODE_ATOMIC_NOTIFY, msg: "atomic.notify");
1385 writeMemArg(os, alignment: 2, offset: 0);
1386 writeU8(os, byte: WASM_OPCODE_DROP, msg: "drop");
1387
1388 // Branch to drop the segments
1389 writeU8(os, byte: WASM_OPCODE_BR, msg: "br");
1390 writeUleb128(os, number: 1, msg: "label $drop");
1391
1392 // Wait for the winning thread to initialize memory
1393 writeU8(os, byte: WASM_OPCODE_END, msg: "end $wait");
1394 writeGetFlagAddress();
1395 writeI32Const(os, number: 1, msg: "expected flag value");
1396 writeI64Const(os, number: -1, msg: "timeout");
1397
1398 writeU8(os, byte: WASM_OPCODE_ATOMICS_PREFIX, msg: "atomics prefix");
1399 writeUleb128(os, number: WASM_OPCODE_I32_ATOMIC_WAIT, msg: "i32.atomic.wait");
1400 writeMemArg(os, alignment: 2, offset: 0);
1401 writeU8(os, byte: WASM_OPCODE_DROP, msg: "drop");
1402
1403 // Unconditionally drop passive data segments
1404 writeU8(os, byte: WASM_OPCODE_END, msg: "end $drop");
1405 }
1406
1407 for (const OutputSegment *s : segments) {
1408 if (needsPassiveInitialization(segment: s) && !s->isBss) {
1409 // The TLS region should not be dropped since its is needed
1410 // during the initialization of each thread (__wasm_init_tls).
1411 if (ctx.arg.sharedMemory && s->isTLS())
1412 continue;
1413 // data.drop instruction
1414 writeU8(os, byte: WASM_OPCODE_MISC_PREFIX, msg: "bulk-memory prefix");
1415 writeUleb128(os, number: WASM_OPCODE_DATA_DROP, msg: "data.drop");
1416 writeUleb128(os, number: s->index, msg: "segment index immediate");
1417 }
1418 }
1419
1420 // End the function
1421 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1422 }
1423
1424 createFunction(func: ctx.sym.initMemory, bodyContent);
1425}
1426
1427void Writer::createStartFunction() {
1428 // If the start function exists when we have more than one function to call.
1429 if (ctx.sym.initMemory && ctx.sym.applyGlobalRelocs) {
1430 assert(ctx.sym.startFunction);
1431 std::string bodyContent;
1432 {
1433 raw_string_ostream os(bodyContent);
1434 writeUleb128(os, number: 0, msg: "num locals");
1435 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1436 writeUleb128(os, number: ctx.sym.applyGlobalRelocs->getFunctionIndex(),
1437 msg: "function index");
1438 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1439 writeUleb128(os, number: ctx.sym.initMemory->getFunctionIndex(),
1440 msg: "function index");
1441 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1442 }
1443 createFunction(func: ctx.sym.startFunction, bodyContent);
1444 } else if (ctx.sym.initMemory) {
1445 ctx.sym.startFunction = ctx.sym.initMemory;
1446 } else if (ctx.sym.applyGlobalRelocs) {
1447 ctx.sym.startFunction = ctx.sym.applyGlobalRelocs;
1448 }
1449}
1450
1451// For -shared (PIC) output, we create create a synthetic function which will
1452// apply any relocations to the data segments on startup. This function is
1453// called `__wasm_apply_data_relocs` and is expected to be called before
1454// any user code (i.e. before `__wasm_call_ctors`).
1455void Writer::createApplyDataRelocationsFunction() {
1456 LLVM_DEBUG(dbgs() << "createApplyDataRelocationsFunction\n");
1457 // First write the body's contents to a string.
1458 std::string bodyContent;
1459 {
1460 raw_string_ostream os(bodyContent);
1461 writeUleb128(os, number: 0, msg: "num locals");
1462 bool generated = false;
1463 for (const OutputSegment *seg : segments)
1464 if (!ctx.arg.sharedMemory || !seg->isTLS())
1465 for (const InputChunk *inSeg : seg->inputSegments)
1466 generated |= inSeg->generateRelocationCode(os);
1467
1468 if (!generated) {
1469 LLVM_DEBUG(dbgs() << "skipping empty __wasm_apply_data_relocs\n");
1470 return;
1471 }
1472 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1473 }
1474
1475 // __wasm_apply_data_relocs
1476 // Function that applies relocations to data segment post-instantiation.
1477 static WasmSignature nullSignature = {{}, {}};
1478 auto def = symtab->addSyntheticFunction(
1479 name: "__wasm_apply_data_relocs",
1480 flags: WASM_SYMBOL_VISIBILITY_DEFAULT | WASM_SYMBOL_EXPORTED,
1481 function: make<SyntheticFunction>(args&: nullSignature, args: "__wasm_apply_data_relocs"));
1482 def->markLive();
1483
1484 createFunction(func: def, bodyContent);
1485}
1486
1487void Writer::createApplyTLSRelocationsFunction() {
1488 LLVM_DEBUG(dbgs() << "createApplyTLSRelocationsFunction\n");
1489 std::string bodyContent;
1490 {
1491 raw_string_ostream os(bodyContent);
1492 writeUleb128(os, number: 0, msg: "num locals");
1493 for (const OutputSegment *seg : segments)
1494 if (seg->isTLS())
1495 for (const InputChunk *inSeg : seg->inputSegments)
1496 inSeg->generateRelocationCode(os);
1497
1498 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1499 }
1500
1501 createFunction(func: ctx.sym.applyTLSRelocs, bodyContent);
1502}
1503
1504// Similar to createApplyDataRelocationsFunction but generates relocation code
1505// for WebAssembly globals. Because these globals are not shared between threads
1506// these relocation need to run on every thread.
1507void Writer::createApplyGlobalRelocationsFunction() {
1508 // First write the body's contents to a string.
1509 std::string bodyContent;
1510 {
1511 raw_string_ostream os(bodyContent);
1512 writeUleb128(os, number: 0, msg: "num locals");
1513 out.globalSec->generateRelocationCode(os, TLS: false);
1514 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1515 }
1516
1517 createFunction(func: ctx.sym.applyGlobalRelocs, bodyContent);
1518}
1519
1520// Similar to createApplyGlobalRelocationsFunction but for
1521// TLS symbols. This cannot be run during the start function
1522// but must be delayed until __wasm_init_tls is called.
1523void Writer::createApplyGlobalTLSRelocationsFunction() {
1524 // First write the body's contents to a string.
1525 std::string bodyContent;
1526 {
1527 raw_string_ostream os(bodyContent);
1528 writeUleb128(os, number: 0, msg: "num locals");
1529 out.globalSec->generateRelocationCode(os, TLS: true);
1530 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1531 }
1532
1533 createFunction(func: ctx.sym.applyGlobalTLSRelocs, bodyContent);
1534}
1535
1536// Create synthetic "__wasm_call_ctors" function based on ctor functions
1537// in input object.
1538void Writer::createCallCtorsFunction() {
1539 // If __wasm_call_ctors isn't referenced, there aren't any ctors, don't
1540 // define the `__wasm_call_ctors` function.
1541 if (!ctx.sym.callCtors->isLive() && initFunctions.empty())
1542 return;
1543
1544 // First write the body's contents to a string.
1545 std::string bodyContent;
1546 {
1547 raw_string_ostream os(bodyContent);
1548 writeUleb128(os, number: 0, msg: "num locals");
1549
1550 // Call constructors
1551 for (const WasmInitEntry &f : initFunctions) {
1552 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1553 writeUleb128(os, number: f.sym->getFunctionIndex(), msg: "function index");
1554 for (size_t i = 0; i < f.sym->signature->Returns.size(); i++) {
1555 writeU8(os, byte: WASM_OPCODE_DROP, msg: "DROP");
1556 }
1557 }
1558
1559 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1560 }
1561
1562 createFunction(func: ctx.sym.callCtors, bodyContent);
1563}
1564
1565// Create a wrapper around a function export which calls the
1566// static constructors and destructors.
1567void Writer::createCommandExportWrapper(uint32_t functionIndex,
1568 DefinedFunction *f) {
1569 // First write the body's contents to a string.
1570 std::string bodyContent;
1571 {
1572 raw_string_ostream os(bodyContent);
1573 writeUleb128(os, number: 0, msg: "num locals");
1574
1575 // Call `__wasm_call_ctors` which call static constructors (and
1576 // applies any runtime relocations in Emscripten-style PIC mode)
1577 if (ctx.sym.callCtors->isLive()) {
1578 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1579 writeUleb128(os, number: ctx.sym.callCtors->getFunctionIndex(), msg: "function index");
1580 }
1581
1582 // Call the user's code, leaving any return values on the operand stack.
1583 for (size_t i = 0; i < f->signature->Params.size(); ++i) {
1584 writeU8(os, byte: WASM_OPCODE_LOCAL_GET, msg: "local.get");
1585 writeUleb128(os, number: i, msg: "local index");
1586 }
1587 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1588 writeUleb128(os, number: functionIndex, msg: "function index");
1589
1590 // Call the function that calls the destructors.
1591 if (DefinedFunction *callDtors = ctx.sym.callDtors) {
1592 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1593 writeUleb128(os, number: callDtors->getFunctionIndex(), msg: "function index");
1594 }
1595
1596 // End the function, returning the return values from the user's code.
1597 writeU8(os, byte: WASM_OPCODE_END, msg: "END");
1598 }
1599
1600 createFunction(func: f, bodyContent);
1601}
1602
1603void Writer::createInitTLSFunction() {
1604 std::string bodyContent;
1605 {
1606 raw_string_ostream os(bodyContent);
1607
1608 OutputSegment *tlsSeg = nullptr;
1609 for (auto *seg : segments) {
1610 if (seg->name == ".tdata") {
1611 tlsSeg = seg;
1612 break;
1613 }
1614 }
1615
1616 writeUleb128(os, number: 0, msg: "num locals");
1617 if (tlsSeg) {
1618 writeU8(os, byte: WASM_OPCODE_LOCAL_GET, msg: "local.get");
1619 writeUleb128(os, number: 0, msg: "local index");
1620
1621 writeU8(os, byte: WASM_OPCODE_GLOBAL_SET, msg: "global.set");
1622 writeUleb128(os, number: ctx.sym.tlsBase->getGlobalIndex(), msg: "global index");
1623
1624 // FIXME(wvo): this local needs to be I64 in wasm64, or we need an extend op.
1625 writeU8(os, byte: WASM_OPCODE_LOCAL_GET, msg: "local.get");
1626 writeUleb128(os, number: 0, msg: "local index");
1627
1628 writeI32Const(os, number: 0, msg: "segment offset");
1629
1630 writeI32Const(os, number: tlsSeg->size, msg: "memory region size");
1631
1632 writeU8(os, byte: WASM_OPCODE_MISC_PREFIX, msg: "bulk-memory prefix");
1633 writeUleb128(os, number: WASM_OPCODE_MEMORY_INIT, msg: "MEMORY.INIT");
1634 writeUleb128(os, number: tlsSeg->index, msg: "segment index immediate");
1635 writeU8(os, byte: 0, msg: "memory index immediate");
1636 }
1637
1638 if (ctx.sym.applyTLSRelocs) {
1639 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1640 writeUleb128(os, number: ctx.sym.applyTLSRelocs->getFunctionIndex(),
1641 msg: "function index");
1642 }
1643
1644 if (ctx.sym.applyGlobalTLSRelocs) {
1645 writeU8(os, byte: WASM_OPCODE_CALL, msg: "CALL");
1646 writeUleb128(os, number: ctx.sym.applyGlobalTLSRelocs->getFunctionIndex(),
1647 msg: "function index");
1648 }
1649 writeU8(os, byte: WASM_OPCODE_END, msg: "end function");
1650 }
1651
1652 createFunction(func: ctx.sym.initTLS, bodyContent);
1653}
1654
1655// Populate InitFunctions vector with init functions from all input objects.
1656// This is then used either when creating the output linking section or to
1657// synthesize the "__wasm_call_ctors" function.
1658void Writer::calculateInitFunctions() {
1659 if (!ctx.arg.relocatable && !ctx.sym.callCtors->isLive())
1660 return;
1661
1662 for (ObjFile *file : ctx.objectFiles) {
1663 const WasmLinkingData &l = file->getWasmObj()->linkingData();
1664 for (const WasmInitFunc &f : l.InitFunctions) {
1665 FunctionSymbol *sym = file->getFunctionSymbol(index: f.Symbol);
1666 // comdat exclusions can cause init functions be discarded.
1667 if (sym->isDiscarded() || !sym->isLive())
1668 continue;
1669 if (sym->signature->Params.size() != 0)
1670 error(msg: "constructor functions cannot take arguments: " + toString(sym: *sym));
1671 LLVM_DEBUG(dbgs() << "initFunctions: " << toString(*sym) << "\n");
1672 initFunctions.emplace_back(args: WasmInitEntry{.sym: sym, .priority: f.Priority});
1673 }
1674 }
1675
1676 // Sort in order of priority (lowest first) so that they are called
1677 // in the correct order.
1678 llvm::stable_sort(Range&: initFunctions,
1679 C: [](const WasmInitEntry &l, const WasmInitEntry &r) {
1680 return l.priority < r.priority;
1681 });
1682}
1683
1684void Writer::createSyntheticSections() {
1685 out.dylinkSec = make<DylinkSection>();
1686 out.typeSec = make<TypeSection>();
1687 out.importSec = make<ImportSection>();
1688 out.functionSec = make<FunctionSection>();
1689 out.tableSec = make<TableSection>();
1690 out.memorySec = make<MemorySection>();
1691 out.tagSec = make<TagSection>();
1692 out.globalSec = make<GlobalSection>();
1693 out.exportSec = make<ExportSection>();
1694 out.startSec = make<StartSection>();
1695 out.elemSec = make<ElemSection>();
1696 out.producersSec = make<ProducersSection>();
1697 out.targetFeaturesSec = make<TargetFeaturesSection>();
1698 out.buildIdSec = make<BuildIdSection>();
1699}
1700
1701void Writer::createSyntheticSectionsPostLayout() {
1702 out.dataCountSec = make<DataCountSection>(args&: segments);
1703 out.linkingSec = make<LinkingSection>(args&: initFunctions, args&: segments);
1704 out.nameSec = make<NameSection>(args&: segments);
1705}
1706
1707void Writer::run() {
1708 // For PIC code the table base is assigned dynamically by the loader.
1709 // For non-PIC, we start at 1 so that accessing table index 0 always traps.
1710 if (!ctx.isPic && ctx.sym.definedTableBase)
1711 ctx.sym.definedTableBase->setVA(ctx.arg.tableBase);
1712
1713 log(msg: "-- createOutputSegments");
1714 createOutputSegments();
1715 log(msg: "-- createSyntheticSections");
1716 createSyntheticSections();
1717 log(msg: "-- layoutMemory");
1718 layoutMemory();
1719
1720 if (!ctx.arg.relocatable) {
1721 // Create linker synthesized __start_SECNAME/__stop_SECNAME symbols
1722 // This has to be done after memory layout is performed.
1723 for (const OutputSegment *seg : segments) {
1724 addStartStopSymbols(seg);
1725 }
1726 }
1727
1728 for (auto &pair : ctx.arg.exportedSymbols) {
1729 Symbol *sym = symtab->find(name: pair.first());
1730 if (sym && sym->isDefined())
1731 sym->forceExport = true;
1732 }
1733
1734 // Delay reporting errors about explicit exports until after
1735 // addStartStopSymbols which can create optional symbols.
1736 for (auto &name : ctx.arg.requiredExports) {
1737 Symbol *sym = symtab->find(name);
1738 if (!sym || !sym->isDefined()) {
1739 if (ctx.arg.unresolvedSymbols == UnresolvedPolicy::ReportError)
1740 error(msg: Twine("symbol exported via --export not found: ") + name);
1741 if (ctx.arg.unresolvedSymbols == UnresolvedPolicy::Warn)
1742 warn(msg: Twine("symbol exported via --export not found: ") + name);
1743 }
1744 }
1745
1746 log(msg: "-- populateTargetFeatures");
1747 populateTargetFeatures();
1748
1749 // When outputting PIC code each segment lives at at fixes offset from the
1750 // `__memory_base` import. Unless we support the extended const expression we
1751 // can't do addition inside the constant expression, so we much combine the
1752 // segments into a single one that can live at `__memory_base`.
1753 if (ctx.isPic && !ctx.arg.extendedConst && !ctx.arg.sharedMemory) {
1754 // In shared memory mode all data segments are passive and initialized
1755 // via __wasm_init_memory.
1756 log(msg: "-- combineOutputSegments");
1757 combineOutputSegments();
1758 }
1759
1760 log(msg: "-- createSyntheticSectionsPostLayout");
1761 createSyntheticSectionsPostLayout();
1762 log(msg: "-- populateProducers");
1763 populateProducers();
1764 log(msg: "-- calculateImports");
1765 calculateImports();
1766 log(msg: "-- scanRelocations");
1767 scanRelocations();
1768 log(msg: "-- finalizeIndirectFunctionTable");
1769 finalizeIndirectFunctionTable();
1770 log(msg: "-- createSyntheticInitFunctions");
1771 createSyntheticInitFunctions();
1772 log(msg: "-- assignIndexes");
1773 assignIndexes();
1774 log(msg: "-- calculateInitFunctions");
1775 calculateInitFunctions();
1776
1777 if (!ctx.arg.relocatable) {
1778 // Create linker synthesized functions
1779 if (ctx.sym.applyGlobalRelocs) {
1780 createApplyGlobalRelocationsFunction();
1781 }
1782 if (ctx.sym.applyTLSRelocs) {
1783 createApplyTLSRelocationsFunction();
1784 }
1785 if (ctx.sym.applyGlobalTLSRelocs) {
1786 createApplyGlobalTLSRelocationsFunction();
1787 }
1788 if (ctx.sym.initMemory) {
1789 createInitMemoryFunction();
1790 }
1791 createStartFunction();
1792
1793 createCallCtorsFunction();
1794
1795 // Create export wrappers for commands if needed.
1796 //
1797 // If the input contains a call to `__wasm_call_ctors`, either in one of
1798 // the input objects or an explicit export from the command-line, we
1799 // assume ctors and dtors are taken care of already.
1800 if (!ctx.arg.relocatable && !ctx.isPic &&
1801 !ctx.sym.callCtors->isUsedInRegularObj &&
1802 !ctx.sym.callCtors->isExported()) {
1803 log(msg: "-- createCommandExportWrappers");
1804 createCommandExportWrappers();
1805 }
1806 }
1807
1808 if (ctx.sym.initTLS && ctx.sym.initTLS->isLive()) {
1809 log(msg: "-- createInitTLSFunction");
1810 createInitTLSFunction();
1811 }
1812
1813 if (errorCount())
1814 return;
1815
1816 log(msg: "-- calculateTypes");
1817 calculateTypes();
1818 log(msg: "-- calculateExports");
1819 calculateExports();
1820 log(msg: "-- calculateCustomSections");
1821 calculateCustomSections();
1822 log(msg: "-- populateSymtab");
1823 populateSymtab();
1824 log(msg: "-- checkImportExportTargetFeatures");
1825 checkImportExportTargetFeatures();
1826 log(msg: "-- addSections");
1827 addSections();
1828
1829 if (errorHandler().verbose) {
1830 log(msg: "Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
1831 log(msg: "Defined Globals : " + Twine(out.globalSec->numGlobals()));
1832 log(msg: "Defined Tags : " + Twine(out.tagSec->inputTags.size()));
1833 log(msg: "Defined Tables : " + Twine(out.tableSec->inputTables.size()));
1834 log(msg: "Function Imports : " +
1835 Twine(out.importSec->getNumImportedFunctions()));
1836 log(msg: "Global Imports : " + Twine(out.importSec->getNumImportedGlobals()));
1837 log(msg: "Tag Imports : " + Twine(out.importSec->getNumImportedTags()));
1838 log(msg: "Table Imports : " + Twine(out.importSec->getNumImportedTables()));
1839 }
1840
1841 createHeader();
1842 log(msg: "-- finalizeSections");
1843 finalizeSections();
1844
1845 log(msg: "-- writeMapFile");
1846 writeMapFile(outputSections);
1847
1848 log(msg: "-- openFile");
1849 openFile();
1850 if (errorCount())
1851 return;
1852
1853 writeHeader();
1854
1855 log(msg: "-- writeSections");
1856 writeSections();
1857 writeBuildId();
1858 if (errorCount())
1859 return;
1860
1861 if (Error e = buffer->commit())
1862 fatal(msg: "failed to write output '" + buffer->getPath() +
1863 "': " + toString(E: std::move(e)));
1864}
1865
1866// Open a result file.
1867void Writer::openFile() {
1868 log(msg: "writing: " + ctx.arg.outputFile);
1869
1870 Expected<std::unique_ptr<FileOutputBuffer>> bufferOrErr =
1871 FileOutputBuffer::create(FilePath: ctx.arg.outputFile, Size: fileSize,
1872 Flags: FileOutputBuffer::F_executable);
1873
1874 if (!bufferOrErr)
1875 error(msg: "failed to open " + ctx.arg.outputFile + ": " +
1876 toString(E: bufferOrErr.takeError()));
1877 else
1878 buffer = std::move(*bufferOrErr);
1879}
1880
1881void Writer::createHeader() {
1882 raw_string_ostream os(header);
1883 writeBytes(os, bytes: WasmMagic, count: sizeof(WasmMagic), msg: "wasm magic");
1884 writeU32(os, number: WasmVersion, msg: "wasm version");
1885 fileSize += header.size();
1886}
1887
1888void writeResult() { Writer().run(); }
1889
1890} // namespace wasm::lld
1891