1 //===- lib/MC/WasmObjectWriter.cpp - Wasm File Writer ---------------------===//
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
7 //===----------------------------------------------------------------------===//
9 // This file implements Wasm object file writer information.
11 //===----------------------------------------------------------------------===//
13 #include "llvm/ADT/STLExtras.h"
14 #include "llvm/ADT/SmallPtrSet.h"
15 #include "llvm/BinaryFormat/Wasm.h"
16 #include "llvm/Config/llvm-config.h"
17 #include "llvm/MC/MCAsmBackend.h"
18 #include "llvm/MC/MCAsmLayout.h"
19 #include "llvm/MC/MCAssembler.h"
20 #include "llvm/MC/MCContext.h"
21 #include "llvm/MC/MCExpr.h"
22 #include "llvm/MC/MCFixupKindInfo.h"
23 #include "llvm/MC/MCObjectWriter.h"
24 #include "llvm/MC/MCSectionWasm.h"
25 #include "llvm/MC/MCSymbolWasm.h"
26 #include "llvm/MC/MCValue.h"
27 #include "llvm/MC/MCWasmObjectWriter.h"
28 #include "llvm/Support/Casting.h"
29 #include "llvm/Support/Debug.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/LEB128.h"
32 #include "llvm/Support/StringSaver.h"
37 #define DEBUG_TYPE "mc"
41 // Went we ceate the indirect function table we start at 1, so that there is
42 // and emtpy slot at 0 and therefore calling a null function pointer will trap.
43 static const uint32_t InitialTableOffset = 1;
45 // For patching purposes, we need to remember where each section starts, both
46 // for patching up the section size field, and for patching up references to
47 // locations within the section.
48 struct SectionBookkeeping {
49 // Where the size of the section is written.
51 // Where the section header ends (without custom section name).
52 uint64_t PayloadOffset;
53 // Where the contents of the section starts.
54 uint64_t ContentsOffset;
58 // The signature of a wasm function or event, in a struct capable of being used
60 // TODO: Consider using wasm::WasmSignature directly instead.
61 struct WasmSignature {
62 // Support empty and tombstone instances, needed by DenseMap.
63 enum { Plain, Empty, Tombstone } State = Plain;
65 // The return types of the function.
66 SmallVector<wasm::ValType, 1> Returns;
68 // The parameter types of the function.
69 SmallVector<wasm::ValType, 4> Params;
71 bool operator==(const WasmSignature &Other) const {
72 return State == Other.State && Returns == Other.Returns &&
73 Params == Other.Params;
77 // Traits for using WasmSignature in a DenseMap.
78 struct WasmSignatureDenseMapInfo {
79 static WasmSignature getEmptyKey() {
81 Sig.State = WasmSignature::Empty;
84 static WasmSignature getTombstoneKey() {
86 Sig.State = WasmSignature::Tombstone;
89 static unsigned getHashValue(const WasmSignature &Sig) {
90 uintptr_t Value = Sig.State;
91 for (wasm::ValType Ret : Sig.Returns)
92 Value += DenseMapInfo<uint32_t>::getHashValue(uint32_t(Ret));
93 for (wasm::ValType Param : Sig.Params)
94 Value += DenseMapInfo<uint32_t>::getHashValue(uint32_t(Param));
97 static bool isEqual(const WasmSignature &LHS, const WasmSignature &RHS) {
102 // A wasm data segment. A wasm binary contains only a single data section
103 // but that can contain many segments, each with their own virtual location
104 // in memory. Each MCSection data created by llvm is modeled as its own
105 // wasm data segment.
106 struct WasmDataSegment {
107 MCSectionWasm *Section;
112 uint32_t LinkerFlags;
113 SmallVector<char, 4> Data;
116 // A wasm function to be written into the function section.
117 struct WasmFunction {
119 const MCSymbolWasm *Sym;
122 // A wasm global to be written into the global section.
124 wasm::WasmGlobalType Type;
125 uint64_t InitialValue;
128 // Information about a single item which is part of a COMDAT. For each data
129 // segment or function which is in the COMDAT, there is a corresponding
131 struct WasmComdatEntry {
136 // Information about a single relocation.
137 struct WasmRelocationEntry {
138 uint64_t Offset; // Where is the relocation.
139 const MCSymbolWasm *Symbol; // The symbol to relocate with.
140 int64_t Addend; // A value to add to the symbol.
141 unsigned Type; // The type of the relocation.
142 const MCSectionWasm *FixupSection; // The section the relocation is targeting.
144 WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
145 int64_t Addend, unsigned Type,
146 const MCSectionWasm *FixupSection)
147 : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
148 FixupSection(FixupSection) {}
150 bool hasAddend() const {
152 case wasm::R_WASM_MEMORY_ADDR_LEB:
153 case wasm::R_WASM_MEMORY_ADDR_SLEB:
154 case wasm::R_WASM_MEMORY_ADDR_I32:
155 case wasm::R_WASM_FUNCTION_OFFSET_I32:
156 case wasm::R_WASM_SECTION_OFFSET_I32:
163 void print(raw_ostream &Out) const {
164 Out << wasm::relocTypetoString(Type) << " Off=" << Offset
165 << ", Sym=" << *Symbol << ", Addend=" << Addend
166 << ", FixupSection=" << FixupSection->getSectionName();
169 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
170 LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
174 static const uint32_t InvalidIndex = -1;
176 struct WasmCustomSection {
179 MCSectionWasm *Section;
181 uint32_t OutputContentsOffset;
182 uint32_t OutputIndex;
184 WasmCustomSection(StringRef Name, MCSectionWasm *Section)
185 : Name(Name), Section(Section), OutputContentsOffset(0),
186 OutputIndex(InvalidIndex) {}
190 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
196 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
197 // to allow patching.
198 static void writePatchableLEB(raw_pwrite_stream &Stream, uint32_t X,
201 unsigned SizeLen = encodeULEB128(X, Buffer, 5);
202 assert(SizeLen == 5);
203 Stream.pwrite((char *)Buffer, SizeLen, Offset);
206 // Write X as an signed LEB value at offset Offset in Stream, padded
207 // to allow patching.
208 static void writePatchableSLEB(raw_pwrite_stream &Stream, int32_t X,
211 unsigned SizeLen = encodeSLEB128(X, Buffer, 5);
212 assert(SizeLen == 5);
213 Stream.pwrite((char *)Buffer, SizeLen, Offset);
216 // Write X as a plain integer value at offset Offset in Stream.
217 static void writeI32(raw_pwrite_stream &Stream, uint32_t X, uint64_t Offset) {
219 support::endian::write32le(Buffer, X);
220 Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
223 class WasmObjectWriter : public MCObjectWriter {
224 support::endian::Writer W;
226 /// The target specific Wasm writer instance.
227 std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
229 // Relocations for fixing up references in the code section.
230 std::vector<WasmRelocationEntry> CodeRelocations;
231 uint32_t CodeSectionIndex;
233 // Relocations for fixing up references in the data section.
234 std::vector<WasmRelocationEntry> DataRelocations;
235 uint32_t DataSectionIndex;
237 // Index values to use for fixing up call_indirect type indices.
238 // Maps function symbols to the index of the type of the function
239 DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
240 // Maps function symbols to the table element index space. Used
241 // for TABLE_INDEX relocation types (i.e. address taken functions).
242 DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
243 // Maps function/global symbols to the function/global/event/section index
245 DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
246 // Maps data symbols to the Wasm segment and offset/size with the segment.
247 DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
249 // Stores output data (index, relocations, content offset) for custom
251 std::vector<WasmCustomSection> CustomSections;
252 std::unique_ptr<WasmCustomSection> ProducersSection;
253 std::unique_ptr<WasmCustomSection> TargetFeaturesSection;
254 // Relocations for fixing up references in the custom sections.
255 DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
256 CustomSectionsRelocations;
258 // Map from section to defining function symbol.
259 DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
261 DenseMap<WasmSignature, uint32_t, WasmSignatureDenseMapInfo> SignatureIndices;
262 SmallVector<WasmSignature, 4> Signatures;
263 SmallVector<WasmGlobal, 4> Globals;
264 SmallVector<WasmDataSegment, 4> DataSegments;
265 unsigned NumFunctionImports = 0;
266 unsigned NumGlobalImports = 0;
267 unsigned NumEventImports = 0;
268 uint32_t SectionCount = 0;
270 // TargetObjectWriter wrappers.
271 bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
272 unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
273 return TargetObjectWriter->getRelocType(Target, Fixup);
276 void startSection(SectionBookkeeping &Section, unsigned SectionId);
277 void startCustomSection(SectionBookkeeping &Section, StringRef Name);
278 void endSection(SectionBookkeeping &Section);
281 WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
282 raw_pwrite_stream &OS)
283 : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {}
286 void reset() override {
287 CodeRelocations.clear();
288 DataRelocations.clear();
291 TableIndices.clear();
292 DataLocations.clear();
293 CustomSections.clear();
294 ProducersSection.reset();
295 TargetFeaturesSection.reset();
296 CustomSectionsRelocations.clear();
297 SignatureIndices.clear();
300 DataSegments.clear();
301 SectionFunctions.clear();
302 NumFunctionImports = 0;
303 NumGlobalImports = 0;
304 MCObjectWriter::reset();
307 void writeHeader(const MCAssembler &Asm);
309 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
310 const MCFragment *Fragment, const MCFixup &Fixup,
311 MCValue Target, uint64_t &FixedValue) override;
313 void executePostLayoutBinding(MCAssembler &Asm,
314 const MCAsmLayout &Layout) override;
316 uint64_t writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
318 void writeString(const StringRef Str) {
319 encodeULEB128(Str.size(), W.OS);
323 void writeValueType(wasm::ValType Ty) { W.OS << static_cast<char>(Ty); }
325 void writeTypeSection(ArrayRef<WasmSignature> Signatures);
326 void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
327 uint32_t NumElements);
328 void writeFunctionSection(ArrayRef<WasmFunction> Functions);
329 void writeGlobalSection();
330 void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
331 void writeElemSection(ArrayRef<uint32_t> TableElems);
332 void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
333 ArrayRef<WasmFunction> Functions);
334 void writeDataSection();
335 void writeEventSection(ArrayRef<wasm::WasmEventType> Events);
336 void writeRelocSection(uint32_t SectionIndex, StringRef Name,
337 std::vector<WasmRelocationEntry> &Relocations);
338 void writeLinkingMetaDataSection(
339 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
340 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
341 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
342 void writeCustomSection(WasmCustomSection &CustomSection,
343 const MCAssembler &Asm, const MCAsmLayout &Layout);
344 void writeCustomRelocSections();
346 updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
347 const MCAsmLayout &Layout);
349 uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
350 void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
351 uint64_t ContentsOffset);
353 uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
354 uint32_t getFunctionType(const MCSymbolWasm &Symbol);
355 uint32_t getEventType(const MCSymbolWasm &Symbol);
356 void registerFunctionType(const MCSymbolWasm &Symbol);
357 void registerEventType(const MCSymbolWasm &Symbol);
360 } // end anonymous namespace
362 // Write out a section header and a patchable section size field.
363 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
364 unsigned SectionId) {
365 LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
366 W.OS << char(SectionId);
368 Section.SizeOffset = W.OS.tell();
370 // The section size. We don't know the size yet, so reserve enough space
371 // for any 32-bit value; we'll patch it later.
372 encodeULEB128(0, W.OS, 5);
374 // The position where the section starts, for measuring its size.
375 Section.ContentsOffset = W.OS.tell();
376 Section.PayloadOffset = W.OS.tell();
377 Section.Index = SectionCount++;
380 void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
382 LLVM_DEBUG(dbgs() << "startCustomSection " << Name << "\n");
383 startSection(Section, wasm::WASM_SEC_CUSTOM);
385 // The position where the section header ends, for measuring its size.
386 Section.PayloadOffset = W.OS.tell();
388 // Custom sections in wasm also have a string identifier.
391 // The position where the custom section starts.
392 Section.ContentsOffset = W.OS.tell();
395 // Now that the section is complete and we know how big it is, patch up the
396 // section size field at the start of the section.
397 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
398 uint64_t Size = W.OS.tell();
399 // /dev/null doesn't support seek/tell and can report offset of 0.
400 // Simply skip this patching in that case.
404 Size -= Section.PayloadOffset;
405 if (uint32_t(Size) != Size)
406 report_fatal_error("section size does not fit in a uint32_t");
408 LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
410 // Write the final section size to the payload_len field, which follows
411 // the section id byte.
412 writePatchableLEB(static_cast<raw_pwrite_stream &>(W.OS), Size,
416 // Emit the Wasm header.
417 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
418 W.OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
419 W.write<uint32_t>(wasm::WasmVersion);
422 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
423 const MCAsmLayout &Layout) {
424 // Build a map of sections to the function that defines them, for use
425 // in recordRelocation.
426 for (const MCSymbol &S : Asm.symbols()) {
427 const auto &WS = static_cast<const MCSymbolWasm &>(S);
428 if (WS.isDefined() && WS.isFunction() && !WS.isVariable()) {
429 const auto &Sec = static_cast<const MCSectionWasm &>(S.getSection());
430 auto Pair = SectionFunctions.insert(std::make_pair(&Sec, &S));
432 report_fatal_error("section already has a defining function: " +
433 Sec.getSectionName());
438 void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
439 const MCAsmLayout &Layout,
440 const MCFragment *Fragment,
441 const MCFixup &Fixup, MCValue Target,
442 uint64_t &FixedValue) {
443 MCAsmBackend &Backend = Asm.getBackend();
444 bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
445 MCFixupKindInfo::FKF_IsPCRel;
446 const auto &FixupSection = cast<MCSectionWasm>(*Fragment->getParent());
447 uint64_t C = Target.getConstant();
448 uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
449 MCContext &Ctx = Asm.getContext();
451 // The .init_array isn't translated as data, so don't do relocations in it.
452 if (FixupSection.getSectionName().startswith(".init_array"))
455 if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
456 assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
457 "Should not have constructed this");
459 // Let A, B and C being the components of Target and R be the location of
460 // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
461 // If it is pcrel, we want to compute (A - B + C - R).
463 // In general, Wasm has no relocations for -B. It can only represent (A + C)
464 // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
465 // replace B to implement it: (A - R - K + C)
469 "No relocation available to represent this relative expression");
473 const auto &SymB = cast<MCSymbolWasm>(RefB->getSymbol());
475 if (SymB.isUndefined()) {
476 Ctx.reportError(Fixup.getLoc(),
477 Twine("symbol '") + SymB.getName() +
478 "' can not be undefined in a subtraction expression");
482 assert(!SymB.isAbsolute() && "Should have been folded");
483 const MCSection &SecB = SymB.getSection();
484 if (&SecB != &FixupSection) {
485 Ctx.reportError(Fixup.getLoc(),
486 "Cannot represent a difference across sections");
490 uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
491 uint64_t K = SymBOffset - FixupOffset;
496 // We either rejected the fixup or folded B into C at this point.
497 const MCSymbolRefExpr *RefA = Target.getSymA();
498 const auto *SymA = RefA ? cast<MCSymbolWasm>(&RefA->getSymbol()) : nullptr;
500 if (SymA && SymA->isVariable()) {
501 const MCExpr *Expr = SymA->getVariableValue();
502 const auto *Inner = cast<MCSymbolRefExpr>(Expr);
503 if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF)
504 llvm_unreachable("weakref used in reloc not yet implemented");
507 // Put any constant offset in an addend. Offsets can be negative, and
508 // LLVM expects wrapping, in contrast to wasm's immediates which can't
509 // be negative and don't wrap.
512 unsigned Type = getRelocType(Target, Fixup);
516 // Absolute offset within a section or a function.
517 // Currently only supported for for metadata sections.
518 // See: test/MC/WebAssembly/blockaddress.ll
519 if (Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
520 Type == wasm::R_WASM_SECTION_OFFSET_I32) {
521 if (!FixupSection.getKind().isMetadata())
522 report_fatal_error("relocations for function or section offsets are "
523 "only supported in metadata sections");
525 const MCSymbol *SectionSymbol = nullptr;
526 const MCSection &SecA = SymA->getSection();
527 if (SecA.getKind().isText())
528 SectionSymbol = SectionFunctions.find(&SecA)->second;
530 SectionSymbol = SecA.getBeginSymbol();
532 report_fatal_error("section symbol is required for relocation");
534 C += Layout.getSymbolOffset(*SymA);
535 SymA = cast<MCSymbolWasm>(SectionSymbol);
538 // Relocation other than R_WASM_TYPE_INDEX_LEB are required to be
539 // against a named symbol.
540 if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
541 if (SymA->getName().empty())
542 report_fatal_error("relocations against un-named temporaries are not yet "
543 "supported by wasm");
545 SymA->setUsedInReloc();
548 WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
549 LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
551 if (FixupSection.isWasmData()) {
552 DataRelocations.push_back(Rec);
553 } else if (FixupSection.getKind().isText()) {
554 CodeRelocations.push_back(Rec);
555 } else if (FixupSection.getKind().isMetadata()) {
556 CustomSectionsRelocations[&FixupSection].push_back(Rec);
558 llvm_unreachable("unexpected section type");
562 static const MCSymbolWasm *resolveSymbol(const MCSymbolWasm &Symbol) {
563 const MCSymbolWasm* Ret = &Symbol;
564 while (Ret->isVariable()) {
565 const MCExpr *Expr = Ret->getVariableValue();
566 auto *Inner = cast<MCSymbolRefExpr>(Expr);
567 Ret = cast<MCSymbolWasm>(&Inner->getSymbol());
572 // Compute a value to write into the code at the location covered
573 // by RelEntry. This value isn't used by the static linker; it just serves
574 // to make the object format more readable and more likely to be directly
577 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
578 switch (RelEntry.Type) {
579 case wasm::R_WASM_TABLE_INDEX_SLEB:
580 case wasm::R_WASM_TABLE_INDEX_I32: {
581 // Provisional value is table address of the resolved symbol itself
582 const MCSymbolWasm *Sym = resolveSymbol(*RelEntry.Symbol);
583 assert(Sym->isFunction());
584 return TableIndices[Sym];
586 case wasm::R_WASM_TYPE_INDEX_LEB:
587 // Provisional value is same as the index
588 return getRelocationIndexValue(RelEntry);
589 case wasm::R_WASM_FUNCTION_INDEX_LEB:
590 case wasm::R_WASM_GLOBAL_INDEX_LEB:
591 case wasm::R_WASM_EVENT_INDEX_LEB:
592 // Provisional value is function/global/event Wasm index
593 if (!WasmIndices.count(RelEntry.Symbol))
594 report_fatal_error("symbol not found in wasm index space: " +
595 RelEntry.Symbol->getName());
596 return WasmIndices[RelEntry.Symbol];
597 case wasm::R_WASM_FUNCTION_OFFSET_I32:
598 case wasm::R_WASM_SECTION_OFFSET_I32: {
599 const auto &Section =
600 static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
601 return Section.getSectionOffset() + RelEntry.Addend;
603 case wasm::R_WASM_MEMORY_ADDR_LEB:
604 case wasm::R_WASM_MEMORY_ADDR_I32:
605 case wasm::R_WASM_MEMORY_ADDR_SLEB: {
606 // Provisional value is address of the global
607 const MCSymbolWasm *Sym = resolveSymbol(*RelEntry.Symbol);
608 // For undefined symbols, use zero
609 if (!Sym->isDefined())
611 const wasm::WasmDataReference &Ref = DataLocations[Sym];
612 const WasmDataSegment &Segment = DataSegments[Ref.Segment];
613 // Ignore overflow. LLVM allows address arithmetic to silently wrap.
614 return Segment.Offset + Ref.Offset + RelEntry.Addend;
617 llvm_unreachable("invalid relocation type");
621 static void addData(SmallVectorImpl<char> &DataBytes,
622 MCSectionWasm &DataSection) {
623 LLVM_DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
625 DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
627 for (const MCFragment &Frag : DataSection) {
628 if (Frag.hasInstructions())
629 report_fatal_error("only data supported in data sections");
631 if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
632 if (Align->getValueSize() != 1)
633 report_fatal_error("only byte values supported for alignment");
634 // If nops are requested, use zeros, as this is the data section.
635 uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
637 std::min<uint64_t>(alignTo(DataBytes.size(), Align->getAlignment()),
638 DataBytes.size() + Align->getMaxBytesToEmit());
639 DataBytes.resize(Size, Value);
640 } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
642 if (!Fill->getNumValues().evaluateAsAbsolute(NumValues))
643 llvm_unreachable("The fill should be an assembler constant");
644 DataBytes.insert(DataBytes.end(), Fill->getValueSize() * NumValues,
646 } else if (auto *LEB = dyn_cast<MCLEBFragment>(&Frag)) {
647 const SmallVectorImpl<char> &Contents = LEB->getContents();
648 DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
650 const auto &DataFrag = cast<MCDataFragment>(Frag);
651 const SmallVectorImpl<char> &Contents = DataFrag.getContents();
652 DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
656 LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
660 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
661 if (RelEntry.Type == wasm::R_WASM_TYPE_INDEX_LEB) {
662 if (!TypeIndices.count(RelEntry.Symbol))
663 report_fatal_error("symbol not found in type index space: " +
664 RelEntry.Symbol->getName());
665 return TypeIndices[RelEntry.Symbol];
668 return RelEntry.Symbol->getIndex();
671 // Apply the portions of the relocation records that we can handle ourselves
673 void WasmObjectWriter::applyRelocations(
674 ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
675 auto &Stream = static_cast<raw_pwrite_stream &>(W.OS);
676 for (const WasmRelocationEntry &RelEntry : Relocations) {
677 uint64_t Offset = ContentsOffset +
678 RelEntry.FixupSection->getSectionOffset() +
681 LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
682 uint32_t Value = getProvisionalValue(RelEntry);
684 switch (RelEntry.Type) {
685 case wasm::R_WASM_FUNCTION_INDEX_LEB:
686 case wasm::R_WASM_TYPE_INDEX_LEB:
687 case wasm::R_WASM_GLOBAL_INDEX_LEB:
688 case wasm::R_WASM_MEMORY_ADDR_LEB:
689 case wasm::R_WASM_EVENT_INDEX_LEB:
690 writePatchableLEB(Stream, Value, Offset);
692 case wasm::R_WASM_TABLE_INDEX_I32:
693 case wasm::R_WASM_MEMORY_ADDR_I32:
694 case wasm::R_WASM_FUNCTION_OFFSET_I32:
695 case wasm::R_WASM_SECTION_OFFSET_I32:
696 writeI32(Stream, Value, Offset);
698 case wasm::R_WASM_TABLE_INDEX_SLEB:
699 case wasm::R_WASM_MEMORY_ADDR_SLEB:
700 writePatchableSLEB(Stream, Value, Offset);
703 llvm_unreachable("invalid relocation type");
708 void WasmObjectWriter::writeTypeSection(ArrayRef<WasmSignature> Signatures) {
709 if (Signatures.empty())
712 SectionBookkeeping Section;
713 startSection(Section, wasm::WASM_SEC_TYPE);
715 encodeULEB128(Signatures.size(), W.OS);
717 for (const WasmSignature &Sig : Signatures) {
718 W.OS << char(wasm::WASM_TYPE_FUNC);
719 encodeULEB128(Sig.Params.size(), W.OS);
720 for (wasm::ValType Ty : Sig.Params)
722 encodeULEB128(Sig.Returns.size(), W.OS);
723 for (wasm::ValType Ty : Sig.Returns)
730 void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
732 uint32_t NumElements) {
736 uint32_t NumPages = (DataSize + wasm::WasmPageSize - 1) / wasm::WasmPageSize;
738 SectionBookkeeping Section;
739 startSection(Section, wasm::WASM_SEC_IMPORT);
741 encodeULEB128(Imports.size(), W.OS);
742 for (const wasm::WasmImport &Import : Imports) {
743 writeString(Import.Module);
744 writeString(Import.Field);
745 W.OS << char(Import.Kind);
747 switch (Import.Kind) {
748 case wasm::WASM_EXTERNAL_FUNCTION:
749 encodeULEB128(Import.SigIndex, W.OS);
751 case wasm::WASM_EXTERNAL_GLOBAL:
752 W.OS << char(Import.Global.Type);
753 W.OS << char(Import.Global.Mutable ? 1 : 0);
755 case wasm::WASM_EXTERNAL_MEMORY:
756 encodeULEB128(0, W.OS); // flags
757 encodeULEB128(NumPages, W.OS); // initial
759 case wasm::WASM_EXTERNAL_TABLE:
760 W.OS << char(Import.Table.ElemType);
761 encodeULEB128(0, W.OS); // flags
762 encodeULEB128(NumElements, W.OS); // initial
764 case wasm::WASM_EXTERNAL_EVENT:
765 encodeULEB128(Import.Event.Attribute, W.OS);
766 encodeULEB128(Import.Event.SigIndex, W.OS);
769 llvm_unreachable("unsupported import kind");
776 void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
777 if (Functions.empty())
780 SectionBookkeeping Section;
781 startSection(Section, wasm::WASM_SEC_FUNCTION);
783 encodeULEB128(Functions.size(), W.OS);
784 for (const WasmFunction &Func : Functions)
785 encodeULEB128(Func.SigIndex, W.OS);
790 void WasmObjectWriter::writeGlobalSection() {
794 SectionBookkeeping Section;
795 startSection(Section, wasm::WASM_SEC_GLOBAL);
797 encodeULEB128(Globals.size(), W.OS);
798 for (const WasmGlobal &Global : Globals) {
799 writeValueType(static_cast<wasm::ValType>(Global.Type.Type));
800 W.OS << char(Global.Type.Mutable);
802 W.OS << char(wasm::WASM_OPCODE_I32_CONST);
803 encodeSLEB128(Global.InitialValue, W.OS);
804 W.OS << char(wasm::WASM_OPCODE_END);
810 void WasmObjectWriter::writeEventSection(ArrayRef<wasm::WasmEventType> Events) {
814 SectionBookkeeping Section;
815 startSection(Section, wasm::WASM_SEC_EVENT);
817 encodeULEB128(Events.size(), W.OS);
818 for (const wasm::WasmEventType &Event : Events) {
819 encodeULEB128(Event.Attribute, W.OS);
820 encodeULEB128(Event.SigIndex, W.OS);
826 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
830 SectionBookkeeping Section;
831 startSection(Section, wasm::WASM_SEC_EXPORT);
833 encodeULEB128(Exports.size(), W.OS);
834 for (const wasm::WasmExport &Export : Exports) {
835 writeString(Export.Name);
836 W.OS << char(Export.Kind);
837 encodeULEB128(Export.Index, W.OS);
843 void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
844 if (TableElems.empty())
847 SectionBookkeeping Section;
848 startSection(Section, wasm::WASM_SEC_ELEM);
850 encodeULEB128(1, W.OS); // number of "segments"
851 encodeULEB128(0, W.OS); // the table index
853 // init expr for starting offset
854 W.OS << char(wasm::WASM_OPCODE_I32_CONST);
855 encodeSLEB128(InitialTableOffset, W.OS);
856 W.OS << char(wasm::WASM_OPCODE_END);
858 encodeULEB128(TableElems.size(), W.OS);
859 for (uint32_t Elem : TableElems)
860 encodeULEB128(Elem, W.OS);
865 void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
866 const MCAsmLayout &Layout,
867 ArrayRef<WasmFunction> Functions) {
868 if (Functions.empty())
871 SectionBookkeeping Section;
872 startSection(Section, wasm::WASM_SEC_CODE);
873 CodeSectionIndex = Section.Index;
875 encodeULEB128(Functions.size(), W.OS);
877 for (const WasmFunction &Func : Functions) {
878 auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
881 if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
882 report_fatal_error(".size expression must be evaluatable");
884 encodeULEB128(Size, W.OS);
885 FuncSection.setSectionOffset(W.OS.tell() - Section.ContentsOffset);
886 Asm.writeSectionData(W.OS, &FuncSection, Layout);
890 applyRelocations(CodeRelocations, Section.ContentsOffset);
895 void WasmObjectWriter::writeDataSection() {
896 if (DataSegments.empty())
899 SectionBookkeeping Section;
900 startSection(Section, wasm::WASM_SEC_DATA);
901 DataSectionIndex = Section.Index;
903 encodeULEB128(DataSegments.size(), W.OS); // count
905 for (const WasmDataSegment &Segment : DataSegments) {
906 encodeULEB128(Segment.InitFlags, W.OS); // flags
907 if (Segment.InitFlags & wasm::WASM_SEGMENT_HAS_MEMINDEX)
908 encodeULEB128(0, W.OS); // memory index
909 if ((Segment.InitFlags & wasm::WASM_SEGMENT_IS_PASSIVE) == 0) {
910 W.OS << char(wasm::WASM_OPCODE_I32_CONST);
911 encodeSLEB128(Segment.Offset, W.OS); // offset
912 W.OS << char(wasm::WASM_OPCODE_END);
914 encodeULEB128(Segment.Data.size(), W.OS); // size
915 Segment.Section->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
916 W.OS << Segment.Data; // data
920 applyRelocations(DataRelocations, Section.ContentsOffset);
925 void WasmObjectWriter::writeRelocSection(
926 uint32_t SectionIndex, StringRef Name,
927 std::vector<WasmRelocationEntry> &Relocs) {
928 // See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
929 // for descriptions of the reloc sections.
934 // First, ensure the relocations are sorted in offset order. In general they
935 // should already be sorted since `recordRelocation` is called in offset
936 // order, but for the code section we combine many MC sections into single
937 // wasm section, and this order is determined by the order of Asm.Symbols()
938 // not the sections order.
940 Relocs.begin(), Relocs.end(),
941 [](const WasmRelocationEntry &A, const WasmRelocationEntry &B) {
942 return (A.Offset + A.FixupSection->getSectionOffset()) <
943 (B.Offset + B.FixupSection->getSectionOffset());
946 SectionBookkeeping Section;
947 startCustomSection(Section, std::string("reloc.") + Name.str());
949 encodeULEB128(SectionIndex, W.OS);
950 encodeULEB128(Relocs.size(), W.OS);
951 for (const WasmRelocationEntry &RelEntry : Relocs) {
953 RelEntry.Offset + RelEntry.FixupSection->getSectionOffset();
954 uint32_t Index = getRelocationIndexValue(RelEntry);
956 W.OS << char(RelEntry.Type);
957 encodeULEB128(Offset, W.OS);
958 encodeULEB128(Index, W.OS);
959 if (RelEntry.hasAddend())
960 encodeSLEB128(RelEntry.Addend, W.OS);
966 void WasmObjectWriter::writeCustomRelocSections() {
967 for (const auto &Sec : CustomSections) {
968 auto &Relocations = CustomSectionsRelocations[Sec.Section];
969 writeRelocSection(Sec.OutputIndex, Sec.Name, Relocations);
973 void WasmObjectWriter::writeLinkingMetaDataSection(
974 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
975 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
976 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
977 SectionBookkeeping Section;
978 startCustomSection(Section, "linking");
979 encodeULEB128(wasm::WasmMetadataVersion, W.OS);
981 SectionBookkeeping SubSection;
982 if (SymbolInfos.size() != 0) {
983 startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
984 encodeULEB128(SymbolInfos.size(), W.OS);
985 for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
986 encodeULEB128(Sym.Kind, W.OS);
987 encodeULEB128(Sym.Flags, W.OS);
989 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
990 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
991 case wasm::WASM_SYMBOL_TYPE_EVENT:
992 encodeULEB128(Sym.ElementIndex, W.OS);
993 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
994 (Sym.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
995 writeString(Sym.Name);
997 case wasm::WASM_SYMBOL_TYPE_DATA:
998 writeString(Sym.Name);
999 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
1000 encodeULEB128(Sym.DataRef.Segment, W.OS);
1001 encodeULEB128(Sym.DataRef.Offset, W.OS);
1002 encodeULEB128(Sym.DataRef.Size, W.OS);
1005 case wasm::WASM_SYMBOL_TYPE_SECTION: {
1006 const uint32_t SectionIndex =
1007 CustomSections[Sym.ElementIndex].OutputIndex;
1008 encodeULEB128(SectionIndex, W.OS);
1012 llvm_unreachable("unexpected kind");
1015 endSection(SubSection);
1018 if (DataSegments.size()) {
1019 startSection(SubSection, wasm::WASM_SEGMENT_INFO);
1020 encodeULEB128(DataSegments.size(), W.OS);
1021 for (const WasmDataSegment &Segment : DataSegments) {
1022 writeString(Segment.Name);
1023 encodeULEB128(Segment.Alignment, W.OS);
1024 encodeULEB128(Segment.LinkerFlags, W.OS);
1026 endSection(SubSection);
1029 if (!InitFuncs.empty()) {
1030 startSection(SubSection, wasm::WASM_INIT_FUNCS);
1031 encodeULEB128(InitFuncs.size(), W.OS);
1032 for (auto &StartFunc : InitFuncs) {
1033 encodeULEB128(StartFunc.first, W.OS); // priority
1034 encodeULEB128(StartFunc.second, W.OS); // function index
1036 endSection(SubSection);
1039 if (Comdats.size()) {
1040 startSection(SubSection, wasm::WASM_COMDAT_INFO);
1041 encodeULEB128(Comdats.size(), W.OS);
1042 for (const auto &C : Comdats) {
1043 writeString(C.first);
1044 encodeULEB128(0, W.OS); // flags for future use
1045 encodeULEB128(C.second.size(), W.OS);
1046 for (const WasmComdatEntry &Entry : C.second) {
1047 encodeULEB128(Entry.Kind, W.OS);
1048 encodeULEB128(Entry.Index, W.OS);
1051 endSection(SubSection);
1054 endSection(Section);
1057 void WasmObjectWriter::writeCustomSection(WasmCustomSection &CustomSection,
1058 const MCAssembler &Asm,
1059 const MCAsmLayout &Layout) {
1060 SectionBookkeeping Section;
1061 auto *Sec = CustomSection.Section;
1062 startCustomSection(Section, CustomSection.Name);
1064 Sec->setSectionOffset(W.OS.tell() - Section.ContentsOffset);
1065 Asm.writeSectionData(W.OS, Sec, Layout);
1067 CustomSection.OutputContentsOffset = Section.ContentsOffset;
1068 CustomSection.OutputIndex = Section.Index;
1070 endSection(Section);
1073 auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
1074 applyRelocations(Relocations, CustomSection.OutputContentsOffset);
1077 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm &Symbol) {
1078 assert(Symbol.isFunction());
1079 assert(TypeIndices.count(&Symbol));
1080 return TypeIndices[&Symbol];
1083 uint32_t WasmObjectWriter::getEventType(const MCSymbolWasm &Symbol) {
1084 assert(Symbol.isEvent());
1085 assert(TypeIndices.count(&Symbol));
1086 return TypeIndices[&Symbol];
1089 void WasmObjectWriter::registerFunctionType(const MCSymbolWasm &Symbol) {
1090 assert(Symbol.isFunction());
1093 const MCSymbolWasm *ResolvedSym = resolveSymbol(Symbol);
1094 if (auto *Sig = ResolvedSym->getSignature()) {
1095 S.Returns = Sig->Returns;
1096 S.Params = Sig->Params;
1099 auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
1101 Signatures.push_back(S);
1102 TypeIndices[&Symbol] = Pair.first->second;
1104 LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
1105 << " new:" << Pair.second << "\n");
1106 LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
1109 void WasmObjectWriter::registerEventType(const MCSymbolWasm &Symbol) {
1110 assert(Symbol.isEvent());
1112 // TODO Currently we don't generate imported exceptions, but if we do, we
1113 // should have a way of infering types of imported exceptions.
1115 if (auto *Sig = Symbol.getSignature()) {
1116 S.Returns = Sig->Returns;
1117 S.Params = Sig->Params;
1120 auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
1122 Signatures.push_back(S);
1123 TypeIndices[&Symbol] = Pair.first->second;
1125 LLVM_DEBUG(dbgs() << "registerEventType: " << Symbol << " new:" << Pair.second
1127 LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
1130 static bool isInSymtab(const MCSymbolWasm &Sym) {
1131 if (Sym.isUsedInReloc())
1134 if (Sym.isComdat() && !Sym.isDefined())
1137 if (Sym.isTemporary() && Sym.getName().empty())
1140 if (Sym.isTemporary() && Sym.isData() && !Sym.getSize())
1143 if (Sym.isSection())
1149 uint64_t WasmObjectWriter::writeObject(MCAssembler &Asm,
1150 const MCAsmLayout &Layout) {
1151 uint64_t StartOffset = W.OS.tell();
1153 LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
1155 // Collect information from the available symbols.
1156 SmallVector<WasmFunction, 4> Functions;
1157 SmallVector<uint32_t, 4> TableElems;
1158 SmallVector<wasm::WasmImport, 4> Imports;
1159 SmallVector<wasm::WasmExport, 4> Exports;
1160 SmallVector<wasm::WasmEventType, 1> Events;
1161 SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
1162 SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
1163 std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
1164 uint32_t DataSize = 0;
1166 // For now, always emit the memory import, since loads and stores are not
1167 // valid without it. In the future, we could perhaps be more clever and omit
1168 // it if there are no loads or stores.
1169 wasm::WasmImport MemImport;
1170 MemImport.Module = "env";
1171 MemImport.Field = "__linear_memory";
1172 MemImport.Kind = wasm::WASM_EXTERNAL_MEMORY;
1173 Imports.push_back(MemImport);
1175 // For now, always emit the table section, since indirect calls are not
1176 // valid without it. In the future, we could perhaps be more clever and omit
1177 // it if there are no indirect calls.
1178 wasm::WasmImport TableImport;
1179 TableImport.Module = "env";
1180 TableImport.Field = "__indirect_function_table";
1181 TableImport.Kind = wasm::WASM_EXTERNAL_TABLE;
1182 TableImport.Table.ElemType = wasm::WASM_TYPE_FUNCREF;
1183 Imports.push_back(TableImport);
1185 // Populate SignatureIndices, and Imports and WasmIndices for undefined
1186 // symbols. This must be done before populating WasmIndices for defined
1188 for (const MCSymbol &S : Asm.symbols()) {
1189 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1191 // Register types for all functions, including those with private linkage
1192 // (because wasm always needs a type signature).
1193 if (WS.isFunction())
1194 registerFunctionType(WS);
1197 registerEventType(WS);
1199 if (WS.isTemporary())
1202 // If the symbol is not defined in this translation unit, import it.
1203 if (!WS.isDefined() && !WS.isComdat()) {
1204 if (WS.isFunction()) {
1205 wasm::WasmImport Import;
1206 Import.Module = WS.getImportModule();
1207 Import.Field = WS.getImportName();
1208 Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
1209 Import.SigIndex = getFunctionType(WS);
1210 Imports.push_back(Import);
1211 WasmIndices[&WS] = NumFunctionImports++;
1212 } else if (WS.isGlobal()) {
1214 report_fatal_error("undefined global symbol cannot be weak");
1216 wasm::WasmImport Import;
1217 Import.Module = WS.getImportModule();
1218 Import.Field = WS.getImportName();
1219 Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
1220 Import.Global = WS.getGlobalType();
1221 Imports.push_back(Import);
1222 WasmIndices[&WS] = NumGlobalImports++;
1223 } else if (WS.isEvent()) {
1225 report_fatal_error("undefined event symbol cannot be weak");
1227 wasm::WasmImport Import;
1228 Import.Module = WS.getImportModule();
1229 Import.Field = WS.getImportName();
1230 Import.Kind = wasm::WASM_EXTERNAL_EVENT;
1231 Import.Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
1232 Import.Event.SigIndex = getEventType(WS);
1233 Imports.push_back(Import);
1234 WasmIndices[&WS] = NumEventImports++;
1239 // Populate DataSegments and CustomSections, which must be done before
1240 // populating DataLocations.
1241 for (MCSection &Sec : Asm) {
1242 auto &Section = static_cast<MCSectionWasm &>(Sec);
1243 StringRef SectionName = Section.getSectionName();
1245 // .init_array sections are handled specially elsewhere.
1246 if (SectionName.startswith(".init_array"))
1249 // Code is handled separately
1250 if (Section.getKind().isText())
1253 if (Section.isWasmData()) {
1254 uint32_t SegmentIndex = DataSegments.size();
1255 DataSize = alignTo(DataSize, Section.getAlignment());
1256 DataSegments.emplace_back();
1257 WasmDataSegment &Segment = DataSegments.back();
1258 Segment.Name = SectionName;
1260 Section.getPassive() ? (uint32_t)wasm::WASM_SEGMENT_IS_PASSIVE : 0;
1261 Segment.Offset = DataSize;
1262 Segment.Section = &Section;
1263 addData(Segment.Data, Section);
1264 Segment.Alignment = Log2_32(Section.getAlignment());
1265 Segment.LinkerFlags = 0;
1266 DataSize += Segment.Data.size();
1267 Section.setSegmentIndex(SegmentIndex);
1269 if (const MCSymbolWasm *C = Section.getGroup()) {
1270 Comdats[C->getName()].emplace_back(
1271 WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
1274 // Create custom sections
1275 assert(Sec.getKind().isMetadata());
1277 StringRef Name = SectionName;
1279 // For user-defined custom sections, strip the prefix
1280 if (Name.startswith(".custom_section."))
1281 Name = Name.substr(strlen(".custom_section."));
1283 MCSymbol *Begin = Sec.getBeginSymbol();
1285 WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
1286 if (SectionName != Begin->getName())
1287 report_fatal_error("section name and begin symbol should match: " +
1288 Twine(SectionName));
1291 // Separate out the producers and target features sections
1292 if (Name == "producers") {
1293 ProducersSection = llvm::make_unique<WasmCustomSection>(Name, &Section);
1296 if (Name == "target_features") {
1297 TargetFeaturesSection =
1298 llvm::make_unique<WasmCustomSection>(Name, &Section);
1302 CustomSections.emplace_back(Name, &Section);
1306 // Populate WasmIndices and DataLocations for defined symbols.
1307 for (const MCSymbol &S : Asm.symbols()) {
1308 // Ignore unnamed temporary symbols, which aren't ever exported, imported,
1309 // or used in relocations.
1310 if (S.isTemporary() && S.getName().empty())
1313 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1315 dbgs() << "MCSymbol: " << toString(WS.getType()) << " '" << S << "'"
1316 << " isDefined=" << S.isDefined() << " isExternal="
1317 << S.isExternal() << " isTemporary=" << S.isTemporary()
1318 << " isWeak=" << WS.isWeak() << " isHidden=" << WS.isHidden()
1319 << " isVariable=" << WS.isVariable() << "\n");
1321 if (WS.isVariable())
1323 if (WS.isComdat() && !WS.isDefined())
1326 if (WS.isFunction()) {
1328 if (WS.isDefined()) {
1329 if (WS.getOffset() != 0)
1331 "function sections must contain one function each");
1333 if (WS.getSize() == nullptr)
1335 "function symbols must have a size set with .size");
1337 // A definition. Write out the function body.
1338 Index = NumFunctionImports + Functions.size();
1340 Func.SigIndex = getFunctionType(WS);
1342 WasmIndices[&WS] = Index;
1343 Functions.push_back(Func);
1345 auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
1346 if (const MCSymbolWasm *C = Section.getGroup()) {
1347 Comdats[C->getName()].emplace_back(
1348 WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
1351 // An import; the index was assigned above.
1352 Index = WasmIndices.find(&WS)->second;
1355 LLVM_DEBUG(dbgs() << " -> function index: " << Index << "\n");
1357 } else if (WS.isData()) {
1358 if (!isInSymtab(WS))
1361 if (!WS.isDefined()) {
1362 LLVM_DEBUG(dbgs() << " -> segment index: -1"
1368 report_fatal_error("data symbols must have a size set with .size: " +
1372 if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
1373 report_fatal_error(".size expression must be evaluatable");
1375 auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
1376 assert(DataSection.isWasmData());
1378 // For each data symbol, export it in the symtab as a reference to the
1379 // corresponding Wasm data segment.
1380 wasm::WasmDataReference Ref = wasm::WasmDataReference{
1381 DataSection.getSegmentIndex(),
1382 static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
1383 static_cast<uint32_t>(Size)};
1384 DataLocations[&WS] = Ref;
1385 LLVM_DEBUG(dbgs() << " -> segment index: " << Ref.Segment << "\n");
1387 } else if (WS.isGlobal()) {
1388 // A "true" Wasm global (currently just __stack_pointer)
1390 report_fatal_error("don't yet support defined globals");
1392 // An import; the index was assigned above
1393 LLVM_DEBUG(dbgs() << " -> global index: "
1394 << WasmIndices.find(&WS)->second << "\n");
1396 } else if (WS.isEvent()) {
1397 // C++ exception symbol (__cpp_exception)
1399 if (WS.isDefined()) {
1400 Index = NumEventImports + Events.size();
1401 wasm::WasmEventType Event;
1402 Event.SigIndex = getEventType(WS);
1403 Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
1404 WasmIndices[&WS] = Index;
1405 Events.push_back(Event);
1407 // An import; the index was assigned above.
1408 Index = WasmIndices.find(&WS)->second;
1410 LLVM_DEBUG(dbgs() << " -> event index: " << WasmIndices.find(&WS)->second
1414 assert(WS.isSection());
1418 // Populate WasmIndices and DataLocations for aliased symbols. We need to
1419 // process these in a separate pass because we need to have processed the
1420 // target of the alias before the alias itself and the symbols are not
1421 // necessarily ordered in this way.
1422 for (const MCSymbol &S : Asm.symbols()) {
1423 if (!S.isVariable())
1426 assert(S.isDefined());
1428 // Find the target symbol of this weak alias and export that index
1429 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1430 const MCSymbolWasm *ResolvedSym = resolveSymbol(WS);
1431 LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym
1434 if (ResolvedSym->isFunction()) {
1435 assert(WasmIndices.count(ResolvedSym) > 0);
1436 uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
1437 WasmIndices[&WS] = WasmIndex;
1438 LLVM_DEBUG(dbgs() << " -> index:" << WasmIndex << "\n");
1439 } else if (ResolvedSym->isData()) {
1440 assert(DataLocations.count(ResolvedSym) > 0);
1441 const wasm::WasmDataReference &Ref =
1442 DataLocations.find(ResolvedSym)->second;
1443 DataLocations[&WS] = Ref;
1444 LLVM_DEBUG(dbgs() << " -> index:" << Ref.Segment << "\n");
1446 report_fatal_error("don't yet support global/event aliases");
1450 // Finally, populate the symbol table itself, in its "natural" order.
1451 for (const MCSymbol &S : Asm.symbols()) {
1452 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1453 if (!isInSymtab(WS)) {
1454 WS.setIndex(InvalidIndex);
1457 LLVM_DEBUG(dbgs() << "adding to symtab: " << WS << "\n");
1461 Flags |= wasm::WASM_SYMBOL_BINDING_WEAK;
1463 Flags |= wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
1464 if (!WS.isExternal() && WS.isDefined())
1465 Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
1466 if (WS.isUndefined())
1467 Flags |= wasm::WASM_SYMBOL_UNDEFINED;
1468 if (WS.isExported())
1469 Flags |= wasm::WASM_SYMBOL_EXPORTED;
1470 if (WS.getName() != WS.getImportName())
1471 Flags |= wasm::WASM_SYMBOL_EXPLICIT_NAME;
1473 wasm::WasmSymbolInfo Info;
1474 Info.Name = WS.getName();
1475 Info.Kind = WS.getType();
1478 assert(WasmIndices.count(&WS) > 0);
1479 Info.ElementIndex = WasmIndices.find(&WS)->second;
1480 } else if (WS.isDefined()) {
1481 assert(DataLocations.count(&WS) > 0);
1482 Info.DataRef = DataLocations.find(&WS)->second;
1484 WS.setIndex(SymbolInfos.size());
1485 SymbolInfos.emplace_back(Info);
1489 auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
1490 // Functions referenced by a relocation need to put in the table. This is
1491 // purely to make the object file's provisional values readable, and is
1492 // ignored by the linker, which re-calculates the relocations itself.
1493 if (Rel.Type != wasm::R_WASM_TABLE_INDEX_I32 &&
1494 Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB)
1496 assert(Rel.Symbol->isFunction());
1497 const MCSymbolWasm &WS = *resolveSymbol(*Rel.Symbol);
1498 uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
1499 uint32_t TableIndex = TableElems.size() + InitialTableOffset;
1500 if (TableIndices.try_emplace(&WS, TableIndex).second) {
1501 LLVM_DEBUG(dbgs() << " -> adding " << WS.getName()
1502 << " to table: " << TableIndex << "\n");
1503 TableElems.push_back(FunctionIndex);
1504 registerFunctionType(WS);
1508 for (const WasmRelocationEntry &RelEntry : CodeRelocations)
1509 HandleReloc(RelEntry);
1510 for (const WasmRelocationEntry &RelEntry : DataRelocations)
1511 HandleReloc(RelEntry);
1514 // Translate .init_array section contents into start functions.
1515 for (const MCSection &S : Asm) {
1516 const auto &WS = static_cast<const MCSectionWasm &>(S);
1517 if (WS.getSectionName().startswith(".fini_array"))
1518 report_fatal_error(".fini_array sections are unsupported");
1519 if (!WS.getSectionName().startswith(".init_array"))
1521 if (WS.getFragmentList().empty())
1524 // init_array is expected to contain a single non-empty data fragment
1525 if (WS.getFragmentList().size() != 3)
1526 report_fatal_error("only one .init_array section fragment supported");
1528 auto IT = WS.begin();
1529 const MCFragment &EmptyFrag = *IT;
1530 if (EmptyFrag.getKind() != MCFragment::FT_Data)
1531 report_fatal_error(".init_array section should be aligned");
1534 const MCFragment &AlignFrag = *IT;
1535 if (AlignFrag.getKind() != MCFragment::FT_Align)
1536 report_fatal_error(".init_array section should be aligned");
1537 if (cast<MCAlignFragment>(AlignFrag).getAlignment() != (is64Bit() ? 8 : 4))
1538 report_fatal_error(".init_array section should be aligned for pointers");
1540 const MCFragment &Frag = *std::next(IT);
1541 if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
1542 report_fatal_error("only data supported in .init_array section");
1544 uint16_t Priority = UINT16_MAX;
1545 unsigned PrefixLength = strlen(".init_array");
1546 if (WS.getSectionName().size() > PrefixLength) {
1547 if (WS.getSectionName()[PrefixLength] != '.')
1549 ".init_array section priority should start with '.'");
1550 if (WS.getSectionName()
1551 .substr(PrefixLength + 1)
1552 .getAsInteger(10, Priority))
1553 report_fatal_error("invalid .init_array section priority");
1555 const auto &DataFrag = cast<MCDataFragment>(Frag);
1556 const SmallVectorImpl<char> &Contents = DataFrag.getContents();
1557 for (const uint8_t *
1558 P = (const uint8_t *)Contents.data(),
1559 *End = (const uint8_t *)Contents.data() + Contents.size();
1562 report_fatal_error("non-symbolic data in .init_array section");
1564 for (const MCFixup &Fixup : DataFrag.getFixups()) {
1565 assert(Fixup.getKind() ==
1566 MCFixup::getKindForSize(is64Bit() ? 8 : 4, false));
1567 const MCExpr *Expr = Fixup.getValue();
1568 auto *SymRef = dyn_cast<MCSymbolRefExpr>(Expr);
1570 report_fatal_error("fixups in .init_array should be symbol references");
1571 const auto &TargetSym = cast<const MCSymbolWasm>(SymRef->getSymbol());
1572 if (TargetSym.getIndex() == InvalidIndex)
1573 report_fatal_error("symbols in .init_array should exist in symbtab");
1574 if (!TargetSym.isFunction())
1575 report_fatal_error("symbols in .init_array should be for functions");
1576 InitFuncs.push_back(
1577 std::make_pair(Priority, TargetSym.getIndex()));
1581 // Write out the Wasm header.
1584 writeTypeSection(Signatures);
1585 writeImportSection(Imports, DataSize, TableElems.size());
1586 writeFunctionSection(Functions);
1587 // Skip the "table" section; we import the table instead.
1588 // Skip the "memory" section; we import the memory instead.
1589 writeGlobalSection();
1590 writeEventSection(Events);
1591 writeExportSection(Exports);
1592 writeElemSection(TableElems);
1593 writeCodeSection(Asm, Layout, Functions);
1595 for (auto &CustomSection : CustomSections)
1596 writeCustomSection(CustomSection, Asm, Layout);
1597 writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
1598 writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
1599 writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
1600 writeCustomRelocSections();
1601 if (ProducersSection)
1602 writeCustomSection(*ProducersSection, Asm, Layout);
1603 if (TargetFeaturesSection)
1604 writeCustomSection(*TargetFeaturesSection, Asm, Layout);
1606 // TODO: Translate the .comment section to the output.
1607 return W.OS.tell() - StartOffset;
1610 std::unique_ptr<MCObjectWriter>
1611 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
1612 raw_pwrite_stream &OS) {
1613 return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);