1 //===- lib/MC/WasmObjectWriter.cpp - Wasm File Writer ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements Wasm object file writer information.
12 //===----------------------------------------------------------------------===//
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/ADT/SmallPtrSet.h"
16 #include "llvm/BinaryFormat/Wasm.h"
17 #include "llvm/Config/llvm-config.h"
18 #include "llvm/MC/MCAsmBackend.h"
19 #include "llvm/MC/MCAsmLayout.h"
20 #include "llvm/MC/MCAssembler.h"
21 #include "llvm/MC/MCContext.h"
22 #include "llvm/MC/MCExpr.h"
23 #include "llvm/MC/MCFixupKindInfo.h"
24 #include "llvm/MC/MCObjectWriter.h"
25 #include "llvm/MC/MCSectionWasm.h"
26 #include "llvm/MC/MCSymbolWasm.h"
27 #include "llvm/MC/MCValue.h"
28 #include "llvm/MC/MCWasmObjectWriter.h"
29 #include "llvm/Support/Casting.h"
30 #include "llvm/Support/Debug.h"
31 #include "llvm/Support/ErrorHandling.h"
32 #include "llvm/Support/LEB128.h"
33 #include "llvm/Support/StringSaver.h"
38 #define DEBUG_TYPE "mc"
41 static std::string toString(wasm::WasmSymbolType type) {
43 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
44 return "WASM_SYMBOL_TYPE_FUNCTION";
45 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
46 return "WASM_SYMBOL_TYPE_GLOBAL";
47 case wasm::WASM_SYMBOL_TYPE_DATA:
48 return "WASM_SYMBOL_TYPE_DATA";
49 case wasm::WASM_SYMBOL_TYPE_SECTION:
50 return "WASM_SYMBOL_TYPE_SECTION";
52 llvm_unreachable("unknown symbol type");
56 static std::string relocTypetoString(uint32_t type) {
58 #define WASM_RELOC(NAME, VALUE) case VALUE: return #NAME;
59 #include "llvm/BinaryFormat/WasmRelocs.def"
62 llvm_unreachable("uknown reloc type");
68 // Went we ceate the indirect function table we start at 1, so that there is
69 // and emtpy slot at 0 and therefore calling a null function pointer will trap.
70 static const uint32_t kInitialTableOffset = 1;
72 // For patching purposes, we need to remember where each section starts, both
73 // for patching up the section size field, and for patching up references to
74 // locations within the section.
75 struct SectionBookkeeping {
76 // Where the size of the section is written.
78 // Where the section header ends (without custom section name).
79 uint64_t PayloadOffset;
80 // Where the contents of the section starts.
81 uint64_t ContentsOffset;
85 // The signature of a wasm function, in a struct capable of being used as a
87 struct WasmFunctionType {
88 // Support empty and tombstone instances, needed by DenseMap.
89 enum { Plain, Empty, Tombstone } State;
91 // The return types of the function.
92 SmallVector<wasm::ValType, 1> Returns;
94 // The parameter types of the function.
95 SmallVector<wasm::ValType, 4> Params;
97 WasmFunctionType() : State(Plain) {}
99 bool operator==(const WasmFunctionType &Other) const {
100 return State == Other.State && Returns == Other.Returns &&
101 Params == Other.Params;
105 // Traits for using WasmFunctionType in a DenseMap.
106 struct WasmFunctionTypeDenseMapInfo {
107 static WasmFunctionType getEmptyKey() {
108 WasmFunctionType FuncTy;
109 FuncTy.State = WasmFunctionType::Empty;
112 static WasmFunctionType getTombstoneKey() {
113 WasmFunctionType FuncTy;
114 FuncTy.State = WasmFunctionType::Tombstone;
117 static unsigned getHashValue(const WasmFunctionType &FuncTy) {
118 uintptr_t Value = FuncTy.State;
119 for (wasm::ValType Ret : FuncTy.Returns)
120 Value += DenseMapInfo<int32_t>::getHashValue(int32_t(Ret));
121 for (wasm::ValType Param : FuncTy.Params)
122 Value += DenseMapInfo<int32_t>::getHashValue(int32_t(Param));
125 static bool isEqual(const WasmFunctionType &LHS,
126 const WasmFunctionType &RHS) {
131 // A wasm data segment. A wasm binary contains only a single data section
132 // but that can contain many segments, each with their own virtual location
133 // in memory. Each MCSection data created by llvm is modeled as its own
134 // wasm data segment.
135 struct WasmDataSegment {
136 MCSectionWasm *Section;
141 SmallVector<char, 4> Data;
144 // A wasm function to be written into the function section.
145 struct WasmFunction {
147 const MCSymbolWasm *Sym;
150 // A wasm global to be written into the global section.
152 wasm::WasmGlobalType Type;
153 uint64_t InitialValue;
156 // Information about a single item which is part of a COMDAT. For each data
157 // segment or function which is in the COMDAT, there is a corresponding
159 struct WasmComdatEntry {
164 // Information about a single relocation.
165 struct WasmRelocationEntry {
166 uint64_t Offset; // Where is the relocation.
167 const MCSymbolWasm *Symbol; // The symbol to relocate with.
168 int64_t Addend; // A value to add to the symbol.
169 unsigned Type; // The type of the relocation.
170 const MCSectionWasm *FixupSection;// The section the relocation is targeting.
172 WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
173 int64_t Addend, unsigned Type,
174 const MCSectionWasm *FixupSection)
175 : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
176 FixupSection(FixupSection) {}
178 bool hasAddend() const {
180 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
181 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
182 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
183 case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
184 case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
191 void print(raw_ostream &Out) const {
192 Out << relocTypetoString(Type)
193 << " Off=" << Offset << ", Sym=" << *Symbol << ", Addend=" << Addend
194 << ", FixupSection=" << FixupSection->getSectionName();
197 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
198 LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
202 static const uint32_t INVALID_INDEX = -1;
204 struct WasmCustomSection {
207 MCSectionWasm *Section;
209 uint32_t OutputContentsOffset;
210 uint32_t OutputIndex;
212 WasmCustomSection(StringRef Name, MCSectionWasm *Section)
213 : Name(Name), Section(Section), OutputContentsOffset(0),
214 OutputIndex(INVALID_INDEX) {}
218 raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
224 class WasmObjectWriter : public MCObjectWriter {
225 /// The target specific Wasm writer instance.
226 std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
228 // Relocations for fixing up references in the code section.
229 std::vector<WasmRelocationEntry> CodeRelocations;
230 uint32_t CodeSectionIndex;
232 // Relocations for fixing up references in the data section.
233 std::vector<WasmRelocationEntry> DataRelocations;
234 uint32_t DataSectionIndex;
236 // Index values to use for fixing up call_indirect type indices.
237 // Maps function symbols to the index of the type of the function
238 DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
239 // Maps function symbols to the table element index space. Used
240 // for TABLE_INDEX relocation types (i.e. address taken functions).
241 DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
242 // Maps function/global symbols to the function/global/section index space.
243 DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
244 // Maps data symbols to the Wasm segment and offset/size with the segment.
245 DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
247 // Stores output data (index, relocations, content offset) for custom
249 std::vector<WasmCustomSection> CustomSections;
250 // Relocations for fixing up references in the custom sections.
251 DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
252 CustomSectionsRelocations;
254 DenseMap<WasmFunctionType, int32_t, WasmFunctionTypeDenseMapInfo>
256 SmallVector<WasmFunctionType, 4> FunctionTypes;
257 SmallVector<WasmGlobal, 4> Globals;
258 SmallVector<WasmDataSegment, 4> DataSegments;
259 unsigned NumFunctionImports = 0;
260 unsigned NumGlobalImports = 0;
261 uint32_t SectionCount = 0;
263 // TargetObjectWriter wrappers.
264 bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
265 unsigned getRelocType(const MCValue &Target, const MCFixup &Fixup) const {
266 return TargetObjectWriter->getRelocType(Target, Fixup);
269 void startSection(SectionBookkeeping &Section, unsigned SectionId);
270 void startCustomSection(SectionBookkeeping &Section, StringRef Name);
271 void endSection(SectionBookkeeping &Section);
274 WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
275 raw_pwrite_stream &OS)
276 : MCObjectWriter(OS, /*IsLittleEndian=*/true),
277 TargetObjectWriter(std::move(MOTW)) {}
279 ~WasmObjectWriter() override;
282 void reset() override {
283 CodeRelocations.clear();
284 DataRelocations.clear();
287 TableIndices.clear();
288 DataLocations.clear();
289 CustomSectionsRelocations.clear();
290 FunctionTypeIndices.clear();
291 FunctionTypes.clear();
293 DataSegments.clear();
294 MCObjectWriter::reset();
295 NumFunctionImports = 0;
296 NumGlobalImports = 0;
299 void writeHeader(const MCAssembler &Asm);
301 void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
302 const MCFragment *Fragment, const MCFixup &Fixup,
303 MCValue Target, uint64_t &FixedValue) override;
305 void executePostLayoutBinding(MCAssembler &Asm,
306 const MCAsmLayout &Layout) override;
308 void writeObject(MCAssembler &Asm, const MCAsmLayout &Layout) override;
310 void writeString(const StringRef Str) {
311 encodeULEB128(Str.size(), getStream());
315 void writeValueType(wasm::ValType Ty) {
316 write8(static_cast<uint8_t>(Ty));
319 void writeTypeSection(ArrayRef<WasmFunctionType> FunctionTypes);
320 void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint32_t DataSize,
321 uint32_t NumElements);
322 void writeFunctionSection(ArrayRef<WasmFunction> Functions);
323 void writeGlobalSection();
324 void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
325 void writeElemSection(ArrayRef<uint32_t> TableElems);
326 void writeCodeSection(const MCAssembler &Asm, const MCAsmLayout &Layout,
327 ArrayRef<WasmFunction> Functions);
328 void writeDataSection();
329 void writeRelocSection(uint32_t SectionIndex, StringRef Name,
330 ArrayRef<WasmRelocationEntry> Relocations);
331 void writeLinkingMetaDataSection(
332 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
333 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
334 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
335 void writeCustomSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
336 void writeCustomRelocSections();
338 updateCustomSectionRelocations(const SmallVector<WasmFunction, 4> &Functions,
339 const MCAsmLayout &Layout);
341 uint32_t getProvisionalValue(const WasmRelocationEntry &RelEntry);
342 void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
343 uint64_t ContentsOffset);
345 uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
346 uint32_t getFunctionType(const MCSymbolWasm &Symbol);
347 uint32_t registerFunctionType(const MCSymbolWasm &Symbol);
350 } // end anonymous namespace
352 WasmObjectWriter::~WasmObjectWriter() {}
354 // Write out a section header and a patchable section size field.
355 void WasmObjectWriter::startSection(SectionBookkeeping &Section,
356 unsigned SectionId) {
357 LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
360 Section.SizeOffset = getStream().tell();
362 // The section size. We don't know the size yet, so reserve enough space
363 // for any 32-bit value; we'll patch it later.
364 encodeULEB128(UINT32_MAX, getStream());
366 // The position where the section starts, for measuring its size.
367 Section.ContentsOffset = getStream().tell();
368 Section.PayloadOffset = getStream().tell();
369 Section.Index = SectionCount++;
372 void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
374 LLVM_DEBUG(dbgs() << "startCustomSection " << Name << "\n");
375 startSection(Section, wasm::WASM_SEC_CUSTOM);
377 // The position where the section header ends, for measuring its size.
378 Section.PayloadOffset = getStream().tell();
380 // Custom sections in wasm also have a string identifier.
383 // The position where the custom section starts.
384 Section.ContentsOffset = getStream().tell();
387 // Now that the section is complete and we know how big it is, patch up the
388 // section size field at the start of the section.
389 void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
390 uint64_t Size = getStream().tell() - Section.PayloadOffset;
391 if (uint32_t(Size) != Size)
392 report_fatal_error("section size does not fit in a uint32_t");
394 LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
396 // Write the final section size to the payload_len field, which follows
397 // the section id byte.
399 unsigned SizeLen = encodeULEB128(Size, Buffer, 5);
400 assert(SizeLen == 5);
401 getStream().pwrite((char *)Buffer, SizeLen, Section.SizeOffset);
404 // Emit the Wasm header.
405 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
406 writeBytes(StringRef(wasm::WasmMagic, sizeof(wasm::WasmMagic)));
407 writeLE32(wasm::WasmVersion);
410 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
411 const MCAsmLayout &Layout) {
414 void WasmObjectWriter::recordRelocation(MCAssembler &Asm,
415 const MCAsmLayout &Layout,
416 const MCFragment *Fragment,
417 const MCFixup &Fixup, MCValue Target,
418 uint64_t &FixedValue) {
419 MCAsmBackend &Backend = Asm.getBackend();
420 bool IsPCRel = Backend.getFixupKindInfo(Fixup.getKind()).Flags &
421 MCFixupKindInfo::FKF_IsPCRel;
422 const auto &FixupSection = cast<MCSectionWasm>(*Fragment->getParent());
423 uint64_t C = Target.getConstant();
424 uint64_t FixupOffset = Layout.getFragmentOffset(Fragment) + Fixup.getOffset();
425 MCContext &Ctx = Asm.getContext();
427 // The .init_array isn't translated as data, so don't do relocations in it.
428 if (FixupSection.getSectionName().startswith(".init_array"))
431 if (const MCSymbolRefExpr *RefB = Target.getSymB()) {
432 assert(RefB->getKind() == MCSymbolRefExpr::VK_None &&
433 "Should not have constructed this");
435 // Let A, B and C being the components of Target and R be the location of
436 // the fixup. If the fixup is not pcrel, we want to compute (A - B + C).
437 // If it is pcrel, we want to compute (A - B + C - R).
439 // In general, Wasm has no relocations for -B. It can only represent (A + C)
440 // or (A + C - R). If B = R + K and the relocation is not pcrel, we can
441 // replace B to implement it: (A - R - K + C)
445 "No relocation available to represent this relative expression");
449 const auto &SymB = cast<MCSymbolWasm>(RefB->getSymbol());
451 if (SymB.isUndefined()) {
452 Ctx.reportError(Fixup.getLoc(),
453 Twine("symbol '") + SymB.getName() +
454 "' can not be undefined in a subtraction expression");
458 assert(!SymB.isAbsolute() && "Should have been folded");
459 const MCSection &SecB = SymB.getSection();
460 if (&SecB != &FixupSection) {
461 Ctx.reportError(Fixup.getLoc(),
462 "Cannot represent a difference across sections");
466 uint64_t SymBOffset = Layout.getSymbolOffset(SymB);
467 uint64_t K = SymBOffset - FixupOffset;
472 // We either rejected the fixup or folded B into C at this point.
473 const MCSymbolRefExpr *RefA = Target.getSymA();
474 const auto *SymA = RefA ? cast<MCSymbolWasm>(&RefA->getSymbol()) : nullptr;
476 if (SymA && SymA->isVariable()) {
477 const MCExpr *Expr = SymA->getVariableValue();
478 const auto *Inner = cast<MCSymbolRefExpr>(Expr);
479 if (Inner->getKind() == MCSymbolRefExpr::VK_WEAKREF)
480 llvm_unreachable("weakref used in reloc not yet implemented");
483 // Put any constant offset in an addend. Offsets can be negative, and
484 // LLVM expects wrapping, in contrast to wasm's immediates which can't
485 // be negative and don't wrap.
488 unsigned Type = getRelocType(Target, Fixup);
492 // Absolute offset within a section or a function.
493 // Currently only supported for for metadata sections.
494 // See: test/MC/WebAssembly/blockaddress.ll
495 if (Type == wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32 ||
496 Type == wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32) {
497 if (!FixupSection.getKind().isMetadata())
498 report_fatal_error("relocations for function or section offsets are "
499 "only supported in metadata sections");
501 const MCSymbol *SectionSymbol = nullptr;
502 const MCSection &SecA = SymA->getSection();
503 if (SecA.getKind().isText())
504 SectionSymbol = SecA.begin()->getAtom();
506 SectionSymbol = SecA.getBeginSymbol();
508 report_fatal_error("section symbol is required for relocation");
510 C += Layout.getSymbolOffset(*SymA);
511 SymA = cast<MCSymbolWasm>(SectionSymbol);
514 // Relocation other than R_WEBASSEMBLY_TYPE_INDEX_LEB are required to be
515 // against a named symbol.
516 if (Type != wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
517 if (SymA->getName().empty())
518 report_fatal_error("relocations against un-named temporaries are not yet "
519 "supported by wasm");
521 SymA->setUsedInReloc();
524 WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
525 LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
527 if (FixupSection.isWasmData()) {
528 DataRelocations.push_back(Rec);
529 } else if (FixupSection.getKind().isText()) {
530 CodeRelocations.push_back(Rec);
531 } else if (FixupSection.getKind().isMetadata()) {
532 CustomSectionsRelocations[&FixupSection].push_back(Rec);
534 llvm_unreachable("unexpected section type");
538 // Write X as an (unsigned) LEB value at offset Offset in Stream, padded
539 // to allow patching.
541 WritePatchableLEB(raw_pwrite_stream &Stream, uint32_t X, uint64_t Offset) {
543 unsigned SizeLen = encodeULEB128(X, Buffer, 5);
544 assert(SizeLen == 5);
545 Stream.pwrite((char *)Buffer, SizeLen, Offset);
548 // Write X as an signed LEB value at offset Offset in Stream, padded
549 // to allow patching.
551 WritePatchableSLEB(raw_pwrite_stream &Stream, int32_t X, uint64_t Offset) {
553 unsigned SizeLen = encodeSLEB128(X, Buffer, 5);
554 assert(SizeLen == 5);
555 Stream.pwrite((char *)Buffer, SizeLen, Offset);
558 // Write X as a plain integer value at offset Offset in Stream.
559 static void WriteI32(raw_pwrite_stream &Stream, uint32_t X, uint64_t Offset) {
561 support::endian::write32le(Buffer, X);
562 Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
565 static const MCSymbolWasm* ResolveSymbol(const MCSymbolWasm& Symbol) {
566 if (Symbol.isVariable()) {
567 const MCExpr *Expr = Symbol.getVariableValue();
568 auto *Inner = cast<MCSymbolRefExpr>(Expr);
569 return cast<MCSymbolWasm>(&Inner->getSymbol());
574 // Compute a value to write into the code at the location covered
575 // by RelEntry. This value isn't used by the static linker; it just serves
576 // to make the object format more readable and more likely to be directly
579 WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry) {
580 switch (RelEntry.Type) {
581 case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
582 case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32: {
583 // Provisional value is table address of the resolved symbol itself
584 const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
585 assert(Sym->isFunction());
586 return TableIndices[Sym];
588 case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
589 // Provisional value is same as the index
590 return getRelocationIndexValue(RelEntry);
591 case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
592 case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
593 // Provisional value is function/global Wasm index
594 if (!WasmIndices.count(RelEntry.Symbol))
595 report_fatal_error("symbol not found in wasm index space: " +
596 RelEntry.Symbol->getName());
597 return WasmIndices[RelEntry.Symbol];
598 case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
599 case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32: {
600 const auto &Section =
601 static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
602 return Section.getSectionOffset() + RelEntry.Addend;
604 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
605 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
606 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB: {
607 // Provisional value is address of the global
608 const MCSymbolWasm *Sym = ResolveSymbol(*RelEntry.Symbol);
609 // For undefined symbols, use zero
610 if (!Sym->isDefined())
612 const wasm::WasmDataReference &Ref = DataLocations[Sym];
613 const WasmDataSegment &Segment = DataSegments[Ref.Segment];
614 // Ignore overflow. LLVM allows address arithmetic to silently wrap.
615 return Segment.Offset + Ref.Offset + RelEntry.Addend;
618 llvm_unreachable("invalid relocation type");
622 static void addData(SmallVectorImpl<char> &DataBytes,
623 MCSectionWasm &DataSection) {
624 LLVM_DEBUG(errs() << "addData: " << DataSection.getSectionName() << "\n");
626 DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlignment()));
628 for (const MCFragment &Frag : DataSection) {
629 if (Frag.hasInstructions())
630 report_fatal_error("only data supported in data sections");
632 if (auto *Align = dyn_cast<MCAlignFragment>(&Frag)) {
633 if (Align->getValueSize() != 1)
634 report_fatal_error("only byte values supported for alignment");
635 // If nops are requested, use zeros, as this is the data section.
636 uint8_t Value = Align->hasEmitNops() ? 0 : Align->getValue();
637 uint64_t Size = std::min<uint64_t>(alignTo(DataBytes.size(),
638 Align->getAlignment()),
640 Align->getMaxBytesToEmit());
641 DataBytes.resize(Size, Value);
642 } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
644 if (!Fill->getSize().evaluateAsAbsolute(Size))
645 llvm_unreachable("The fill should be an assembler constant");
646 DataBytes.insert(DataBytes.end(), Size, Fill->getValue());
648 const auto &DataFrag = cast<MCDataFragment>(Frag);
649 const SmallVectorImpl<char> &Contents = DataFrag.getContents();
651 DataBytes.insert(DataBytes.end(), Contents.begin(), Contents.end());
655 LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
659 WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
660 if (RelEntry.Type == wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB) {
661 if (!TypeIndices.count(RelEntry.Symbol))
662 report_fatal_error("symbol not found in type index space: " +
663 RelEntry.Symbol->getName());
664 return TypeIndices[RelEntry.Symbol];
667 return RelEntry.Symbol->getIndex();
670 // Apply the portions of the relocation records that we can handle ourselves
672 void WasmObjectWriter::applyRelocations(
673 ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset) {
674 raw_pwrite_stream &Stream = getStream();
675 for (const WasmRelocationEntry &RelEntry : Relocations) {
676 uint64_t Offset = ContentsOffset +
677 RelEntry.FixupSection->getSectionOffset() +
680 LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
681 uint32_t Value = getProvisionalValue(RelEntry);
683 switch (RelEntry.Type) {
684 case wasm::R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
685 case wasm::R_WEBASSEMBLY_TYPE_INDEX_LEB:
686 case wasm::R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
687 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_LEB:
688 WritePatchableLEB(Stream, Value, Offset);
690 case wasm::R_WEBASSEMBLY_TABLE_INDEX_I32:
691 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_I32:
692 case wasm::R_WEBASSEMBLY_FUNCTION_OFFSET_I32:
693 case wasm::R_WEBASSEMBLY_SECTION_OFFSET_I32:
694 WriteI32(Stream, Value, Offset);
696 case wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB:
697 case wasm::R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
698 WritePatchableSLEB(Stream, Value, Offset);
701 llvm_unreachable("invalid relocation type");
706 void WasmObjectWriter::writeTypeSection(
707 ArrayRef<WasmFunctionType> FunctionTypes) {
708 if (FunctionTypes.empty())
711 SectionBookkeeping Section;
712 startSection(Section, wasm::WASM_SEC_TYPE);
714 encodeULEB128(FunctionTypes.size(), getStream());
716 for (const WasmFunctionType &FuncTy : FunctionTypes) {
717 write8(wasm::WASM_TYPE_FUNC);
718 encodeULEB128(FuncTy.Params.size(), getStream());
719 for (wasm::ValType Ty : FuncTy.Params)
721 encodeULEB128(FuncTy.Returns.size(), getStream());
722 for (wasm::ValType Ty : FuncTy.Returns)
729 void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
731 uint32_t NumElements) {
735 uint32_t NumPages = (DataSize + wasm::WasmPageSize - 1) / wasm::WasmPageSize;
737 SectionBookkeeping Section;
738 startSection(Section, wasm::WASM_SEC_IMPORT);
740 encodeULEB128(Imports.size(), getStream());
741 for (const wasm::WasmImport &Import : Imports) {
742 writeString(Import.Module);
743 writeString(Import.Field);
746 switch (Import.Kind) {
747 case wasm::WASM_EXTERNAL_FUNCTION:
748 encodeULEB128(Import.SigIndex, getStream());
750 case wasm::WASM_EXTERNAL_GLOBAL:
751 write8(Import.Global.Type);
752 write8(Import.Global.Mutable ? 1 : 0);
754 case wasm::WASM_EXTERNAL_MEMORY:
755 encodeULEB128(0, getStream()); // flags
756 encodeULEB128(NumPages, getStream()); // initial
758 case wasm::WASM_EXTERNAL_TABLE:
759 write8(Import.Table.ElemType);
760 encodeULEB128(0, getStream()); // flags
761 encodeULEB128(NumElements, getStream()); // initial
764 llvm_unreachable("unsupported import kind");
771 void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
772 if (Functions.empty())
775 SectionBookkeeping Section;
776 startSection(Section, wasm::WASM_SEC_FUNCTION);
778 encodeULEB128(Functions.size(), getStream());
779 for (const WasmFunction &Func : Functions)
780 encodeULEB128(Func.Type, getStream());
785 void WasmObjectWriter::writeGlobalSection() {
789 SectionBookkeeping Section;
790 startSection(Section, wasm::WASM_SEC_GLOBAL);
792 encodeULEB128(Globals.size(), getStream());
793 for (const WasmGlobal &Global : Globals) {
794 writeValueType(static_cast<wasm::ValType>(Global.Type.Type));
795 write8(Global.Type.Mutable);
797 write8(wasm::WASM_OPCODE_I32_CONST);
798 encodeSLEB128(Global.InitialValue, getStream());
799 write8(wasm::WASM_OPCODE_END);
805 void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
809 SectionBookkeeping Section;
810 startSection(Section, wasm::WASM_SEC_EXPORT);
812 encodeULEB128(Exports.size(), getStream());
813 for (const wasm::WasmExport &Export : Exports) {
814 writeString(Export.Name);
816 encodeULEB128(Export.Index, getStream());
822 void WasmObjectWriter::writeElemSection(ArrayRef<uint32_t> TableElems) {
823 if (TableElems.empty())
826 SectionBookkeeping Section;
827 startSection(Section, wasm::WASM_SEC_ELEM);
829 encodeULEB128(1, getStream()); // number of "segments"
830 encodeULEB128(0, getStream()); // the table index
832 // init expr for starting offset
833 write8(wasm::WASM_OPCODE_I32_CONST);
834 encodeSLEB128(kInitialTableOffset, getStream());
835 write8(wasm::WASM_OPCODE_END);
837 encodeULEB128(TableElems.size(), getStream());
838 for (uint32_t Elem : TableElems)
839 encodeULEB128(Elem, getStream());
844 void WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
845 const MCAsmLayout &Layout,
846 ArrayRef<WasmFunction> Functions) {
847 if (Functions.empty())
850 SectionBookkeeping Section;
851 startSection(Section, wasm::WASM_SEC_CODE);
852 CodeSectionIndex = Section.Index;
854 encodeULEB128(Functions.size(), getStream());
856 for (const WasmFunction &Func : Functions) {
857 auto &FuncSection = static_cast<MCSectionWasm &>(Func.Sym->getSection());
860 if (!Func.Sym->getSize()->evaluateAsAbsolute(Size, Layout))
861 report_fatal_error(".size expression must be evaluatable");
863 encodeULEB128(Size, getStream());
864 FuncSection.setSectionOffset(getStream().tell() - Section.ContentsOffset);
865 Asm.writeSectionData(&FuncSection, Layout);
869 applyRelocations(CodeRelocations, Section.ContentsOffset);
874 void WasmObjectWriter::writeDataSection() {
875 if (DataSegments.empty())
878 SectionBookkeeping Section;
879 startSection(Section, wasm::WASM_SEC_DATA);
880 DataSectionIndex = Section.Index;
882 encodeULEB128(DataSegments.size(), getStream()); // count
884 for (const WasmDataSegment &Segment : DataSegments) {
885 encodeULEB128(0, getStream()); // memory index
886 write8(wasm::WASM_OPCODE_I32_CONST);
887 encodeSLEB128(Segment.Offset, getStream()); // offset
888 write8(wasm::WASM_OPCODE_END);
889 encodeULEB128(Segment.Data.size(), getStream()); // size
890 Segment.Section->setSectionOffset(getStream().tell() - Section.ContentsOffset);
891 writeBytes(Segment.Data); // data
895 applyRelocations(DataRelocations, Section.ContentsOffset);
900 void WasmObjectWriter::writeRelocSection(
901 uint32_t SectionIndex, StringRef Name,
902 ArrayRef<WasmRelocationEntry> Relocations) {
903 // See: https://github.com/WebAssembly/tool-conventions/blob/master/Linking.md
904 // for descriptions of the reloc sections.
906 if (Relocations.empty())
909 SectionBookkeeping Section;
910 startCustomSection(Section, std::string("reloc.") + Name.str());
912 raw_pwrite_stream &Stream = getStream();
914 encodeULEB128(SectionIndex, Stream);
915 encodeULEB128(Relocations.size(), Stream);
916 for (const WasmRelocationEntry& RelEntry : Relocations) {
917 uint64_t Offset = RelEntry.Offset +
918 RelEntry.FixupSection->getSectionOffset();
919 uint32_t Index = getRelocationIndexValue(RelEntry);
921 write8(RelEntry.Type);
922 encodeULEB128(Offset, Stream);
923 encodeULEB128(Index, Stream);
924 if (RelEntry.hasAddend())
925 encodeSLEB128(RelEntry.Addend, Stream);
931 void WasmObjectWriter::writeCustomRelocSections() {
932 for (const auto &Sec : CustomSections) {
933 auto &Relocations = CustomSectionsRelocations[Sec.Section];
934 writeRelocSection(Sec.OutputIndex, Sec.Name, Relocations);
938 void WasmObjectWriter::writeLinkingMetaDataSection(
939 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
940 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
941 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
942 SectionBookkeeping Section;
943 startCustomSection(Section, "linking");
944 encodeULEB128(wasm::WasmMetadataVersion, getStream());
946 SectionBookkeeping SubSection;
947 if (SymbolInfos.size() != 0) {
948 startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
949 encodeULEB128(SymbolInfos.size(), getStream());
950 for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
951 encodeULEB128(Sym.Kind, getStream());
952 encodeULEB128(Sym.Flags, getStream());
954 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
955 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
956 encodeULEB128(Sym.ElementIndex, getStream());
957 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0)
958 writeString(Sym.Name);
960 case wasm::WASM_SYMBOL_TYPE_DATA:
961 writeString(Sym.Name);
962 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
963 encodeULEB128(Sym.DataRef.Segment, getStream());
964 encodeULEB128(Sym.DataRef.Offset, getStream());
965 encodeULEB128(Sym.DataRef.Size, getStream());
968 case wasm::WASM_SYMBOL_TYPE_SECTION: {
969 const uint32_t SectionIndex =
970 CustomSections[Sym.ElementIndex].OutputIndex;
971 encodeULEB128(SectionIndex, getStream());
975 llvm_unreachable("unexpected kind");
978 endSection(SubSection);
981 if (DataSegments.size()) {
982 startSection(SubSection, wasm::WASM_SEGMENT_INFO);
983 encodeULEB128(DataSegments.size(), getStream());
984 for (const WasmDataSegment &Segment : DataSegments) {
985 writeString(Segment.Name);
986 encodeULEB128(Segment.Alignment, getStream());
987 encodeULEB128(Segment.Flags, getStream());
989 endSection(SubSection);
992 if (!InitFuncs.empty()) {
993 startSection(SubSection, wasm::WASM_INIT_FUNCS);
994 encodeULEB128(InitFuncs.size(), getStream());
995 for (auto &StartFunc : InitFuncs) {
996 encodeULEB128(StartFunc.first, getStream()); // priority
997 encodeULEB128(StartFunc.second, getStream()); // function index
999 endSection(SubSection);
1002 if (Comdats.size()) {
1003 startSection(SubSection, wasm::WASM_COMDAT_INFO);
1004 encodeULEB128(Comdats.size(), getStream());
1005 for (const auto &C : Comdats) {
1006 writeString(C.first);
1007 encodeULEB128(0, getStream()); // flags for future use
1008 encodeULEB128(C.second.size(), getStream());
1009 for (const WasmComdatEntry &Entry : C.second) {
1010 encodeULEB128(Entry.Kind, getStream());
1011 encodeULEB128(Entry.Index, getStream());
1014 endSection(SubSection);
1017 endSection(Section);
1020 void WasmObjectWriter::writeCustomSections(const MCAssembler &Asm,
1021 const MCAsmLayout &Layout) {
1022 for (auto &CustomSection : CustomSections) {
1023 SectionBookkeeping Section;
1024 auto *Sec = CustomSection.Section;
1025 startCustomSection(Section, CustomSection.Name);
1027 Sec->setSectionOffset(getStream().tell() - Section.ContentsOffset);
1028 Asm.writeSectionData(Sec, Layout);
1030 CustomSection.OutputContentsOffset = Section.ContentsOffset;
1031 CustomSection.OutputIndex = Section.Index;
1033 endSection(Section);
1036 auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
1037 applyRelocations(Relocations, CustomSection.OutputContentsOffset);
1041 uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm& Symbol) {
1042 assert(Symbol.isFunction());
1043 assert(TypeIndices.count(&Symbol));
1044 return TypeIndices[&Symbol];
1047 uint32_t WasmObjectWriter::registerFunctionType(const MCSymbolWasm& Symbol) {
1048 assert(Symbol.isFunction());
1051 const MCSymbolWasm* ResolvedSym = ResolveSymbol(Symbol);
1052 F.Returns = ResolvedSym->getReturns();
1053 F.Params = ResolvedSym->getParams();
1056 FunctionTypeIndices.insert(std::make_pair(F, FunctionTypes.size()));
1058 FunctionTypes.push_back(F);
1059 TypeIndices[&Symbol] = Pair.first->second;
1061 LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
1062 << " new:" << Pair.second << "\n");
1063 LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
1064 return Pair.first->second;
1067 static bool isInSymtab(const MCSymbolWasm &Sym) {
1068 if (Sym.isUsedInReloc())
1071 if (Sym.isComdat() && !Sym.isDefined())
1074 if (Sym.isTemporary() && Sym.getName().empty())
1077 if (Sym.isTemporary() && Sym.isData() && !Sym.getSize())
1080 if (Sym.isSection())
1086 void WasmObjectWriter::writeObject(MCAssembler &Asm,
1087 const MCAsmLayout &Layout) {
1088 LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
1089 MCContext &Ctx = Asm.getContext();
1091 // Collect information from the available symbols.
1092 SmallVector<WasmFunction, 4> Functions;
1093 SmallVector<uint32_t, 4> TableElems;
1094 SmallVector<wasm::WasmImport, 4> Imports;
1095 SmallVector<wasm::WasmExport, 4> Exports;
1096 SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
1097 SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
1098 std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
1099 uint32_t DataSize = 0;
1101 // For now, always emit the memory import, since loads and stores are not
1102 // valid without it. In the future, we could perhaps be more clever and omit
1103 // it if there are no loads or stores.
1104 MCSymbolWasm *MemorySym =
1105 cast<MCSymbolWasm>(Ctx.getOrCreateSymbol("__linear_memory"));
1106 wasm::WasmImport MemImport;
1107 MemImport.Module = MemorySym->getModuleName();
1108 MemImport.Field = MemorySym->getName();
1109 MemImport.Kind = wasm::WASM_EXTERNAL_MEMORY;
1110 Imports.push_back(MemImport);
1112 // For now, always emit the table section, since indirect calls are not
1113 // valid without it. In the future, we could perhaps be more clever and omit
1114 // it if there are no indirect calls.
1115 MCSymbolWasm *TableSym =
1116 cast<MCSymbolWasm>(Ctx.getOrCreateSymbol("__indirect_function_table"));
1117 wasm::WasmImport TableImport;
1118 TableImport.Module = TableSym->getModuleName();
1119 TableImport.Field = TableSym->getName();
1120 TableImport.Kind = wasm::WASM_EXTERNAL_TABLE;
1121 TableImport.Table.ElemType = wasm::WASM_TYPE_ANYFUNC;
1122 Imports.push_back(TableImport);
1124 // Populate FunctionTypeIndices, and Imports and WasmIndices for undefined
1125 // symbols. This must be done before populating WasmIndices for defined
1127 for (const MCSymbol &S : Asm.symbols()) {
1128 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1130 // Register types for all functions, including those with private linkage
1131 // (because wasm always needs a type signature).
1132 if (WS.isFunction())
1133 registerFunctionType(WS);
1135 if (WS.isTemporary())
1138 // If the symbol is not defined in this translation unit, import it.
1139 if (!WS.isDefined() && !WS.isComdat()) {
1140 if (WS.isFunction()) {
1141 wasm::WasmImport Import;
1142 Import.Module = WS.getModuleName();
1143 Import.Field = WS.getName();
1144 Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
1145 Import.SigIndex = getFunctionType(WS);
1146 Imports.push_back(Import);
1147 WasmIndices[&WS] = NumFunctionImports++;
1148 } else if (WS.isGlobal()) {
1150 report_fatal_error("undefined global symbol cannot be weak");
1152 wasm::WasmImport Import;
1153 Import.Module = WS.getModuleName();
1154 Import.Field = WS.getName();
1155 Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
1156 Import.Global = WS.getGlobalType();
1157 Imports.push_back(Import);
1158 WasmIndices[&WS] = NumGlobalImports++;
1163 // Populate DataSegments and CustomSections, which must be done before
1164 // populating DataLocations.
1165 for (MCSection &Sec : Asm) {
1166 auto &Section = static_cast<MCSectionWasm &>(Sec);
1167 StringRef SectionName = Section.getSectionName();
1169 // .init_array sections are handled specially elsewhere.
1170 if (SectionName.startswith(".init_array"))
1173 // Code is handled separately
1174 if (Section.getKind().isText())
1177 if (Section.isWasmData()) {
1178 uint32_t SegmentIndex = DataSegments.size();
1179 DataSize = alignTo(DataSize, Section.getAlignment());
1180 DataSegments.emplace_back();
1181 WasmDataSegment &Segment = DataSegments.back();
1182 Segment.Name = SectionName;
1183 Segment.Offset = DataSize;
1184 Segment.Section = &Section;
1185 addData(Segment.Data, Section);
1186 Segment.Alignment = Section.getAlignment();
1188 DataSize += Segment.Data.size();
1189 Section.setSegmentIndex(SegmentIndex);
1191 if (const MCSymbolWasm *C = Section.getGroup()) {
1192 Comdats[C->getName()].emplace_back(
1193 WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
1196 // Create custom sections
1197 assert(Sec.getKind().isMetadata());
1199 StringRef Name = SectionName;
1201 // For user-defined custom sections, strip the prefix
1202 if (Name.startswith(".custom_section."))
1203 Name = Name.substr(strlen(".custom_section."));
1205 MCSymbol* Begin = Sec.getBeginSymbol();
1207 WasmIndices[cast<MCSymbolWasm>(Begin)] = CustomSections.size();
1208 if (SectionName != Begin->getName())
1209 report_fatal_error("section name and begin symbol should match: " +
1210 Twine(SectionName));
1212 CustomSections.emplace_back(Name, &Section);
1216 // Populate WasmIndices and DataLocations for defined symbols.
1217 for (const MCSymbol &S : Asm.symbols()) {
1218 // Ignore unnamed temporary symbols, which aren't ever exported, imported,
1219 // or used in relocations.
1220 if (S.isTemporary() && S.getName().empty())
1223 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1225 dbgs() << "MCSymbol: " << toString(WS.getType()) << " '" << S << "'"
1226 << " isDefined=" << S.isDefined() << " isExternal="
1227 << S.isExternal() << " isTemporary=" << S.isTemporary()
1228 << " isWeak=" << WS.isWeak() << " isHidden=" << WS.isHidden()
1229 << " isVariable=" << WS.isVariable() << "\n");
1231 if (WS.isVariable())
1233 if (WS.isComdat() && !WS.isDefined())
1236 if (WS.isFunction()) {
1238 if (WS.isDefined()) {
1239 if (WS.getOffset() != 0)
1241 "function sections must contain one function each");
1243 if (WS.getSize() == 0)
1245 "function symbols must have a size set with .size");
1247 // A definition. Write out the function body.
1248 Index = NumFunctionImports + Functions.size();
1250 Func.Type = getFunctionType(WS);
1252 WasmIndices[&WS] = Index;
1253 Functions.push_back(Func);
1255 auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
1256 if (const MCSymbolWasm *C = Section.getGroup()) {
1257 Comdats[C->getName()].emplace_back(
1258 WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
1261 // An import; the index was assigned above.
1262 Index = WasmIndices.find(&WS)->second;
1265 LLVM_DEBUG(dbgs() << " -> function index: " << Index << "\n");
1266 } else if (WS.isData()) {
1267 if (WS.isTemporary() && !WS.getSize())
1270 if (!WS.isDefined()) {
1271 LLVM_DEBUG(dbgs() << " -> segment index: -1"
1277 report_fatal_error("data symbols must have a size set with .size: " +
1281 if (!WS.getSize()->evaluateAsAbsolute(Size, Layout))
1282 report_fatal_error(".size expression must be evaluatable");
1284 auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
1285 assert(DataSection.isWasmData());
1287 // For each data symbol, export it in the symtab as a reference to the
1288 // corresponding Wasm data segment.
1289 wasm::WasmDataReference Ref = wasm::WasmDataReference{
1290 DataSection.getSegmentIndex(),
1291 static_cast<uint32_t>(Layout.getSymbolOffset(WS)),
1292 static_cast<uint32_t>(Size)};
1293 DataLocations[&WS] = Ref;
1294 LLVM_DEBUG(dbgs() << " -> segment index: " << Ref.Segment << "\n");
1295 } else if (WS.isGlobal()) {
1296 // A "true" Wasm global (currently just __stack_pointer)
1298 report_fatal_error("don't yet support defined globals");
1300 // An import; the index was assigned above
1301 LLVM_DEBUG(dbgs() << " -> global index: "
1302 << WasmIndices.find(&WS)->second << "\n");
1304 assert(WS.isSection());
1308 // Populate WasmIndices and DataLocations for aliased symbols. We need to
1309 // process these in a separate pass because we need to have processed the
1310 // target of the alias before the alias itself and the symbols are not
1311 // necessarily ordered in this way.
1312 for (const MCSymbol &S : Asm.symbols()) {
1313 if (!S.isVariable())
1316 assert(S.isDefined());
1318 // Find the target symbol of this weak alias and export that index
1319 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1320 const MCSymbolWasm *ResolvedSym = ResolveSymbol(WS);
1321 LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *ResolvedSym
1324 if (WS.isFunction()) {
1325 assert(WasmIndices.count(ResolvedSym) > 0);
1326 uint32_t WasmIndex = WasmIndices.find(ResolvedSym)->second;
1327 WasmIndices[&WS] = WasmIndex;
1328 LLVM_DEBUG(dbgs() << " -> index:" << WasmIndex << "\n");
1329 } else if (WS.isData()) {
1330 assert(DataLocations.count(ResolvedSym) > 0);
1331 const wasm::WasmDataReference &Ref =
1332 DataLocations.find(ResolvedSym)->second;
1333 DataLocations[&WS] = Ref;
1334 LLVM_DEBUG(dbgs() << " -> index:" << Ref.Segment << "\n");
1336 report_fatal_error("don't yet support global aliases");
1340 // Finally, populate the symbol table itself, in its "natural" order.
1341 for (const MCSymbol &S : Asm.symbols()) {
1342 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1343 if (!isInSymtab(WS)) {
1344 WS.setIndex(INVALID_INDEX);
1347 LLVM_DEBUG(dbgs() << "adding to symtab: " << WS << "\n");
1351 Flags |= wasm::WASM_SYMBOL_BINDING_WEAK;
1353 Flags |= wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
1354 if (!WS.isExternal() && WS.isDefined())
1355 Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
1356 if (WS.isUndefined())
1357 Flags |= wasm::WASM_SYMBOL_UNDEFINED;
1359 wasm::WasmSymbolInfo Info;
1360 Info.Name = WS.getName();
1361 Info.Kind = WS.getType();
1364 assert(WasmIndices.count(&WS) > 0);
1365 Info.ElementIndex = WasmIndices.find(&WS)->second;
1366 } else if (WS.isDefined()) {
1367 assert(DataLocations.count(&WS) > 0);
1368 Info.DataRef = DataLocations.find(&WS)->second;
1370 WS.setIndex(SymbolInfos.size());
1371 SymbolInfos.emplace_back(Info);
1375 auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
1376 // Functions referenced by a relocation need to put in the table. This is
1377 // purely to make the object file's provisional values readable, and is
1378 // ignored by the linker, which re-calculates the relocations itself.
1379 if (Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_I32 &&
1380 Rel.Type != wasm::R_WEBASSEMBLY_TABLE_INDEX_SLEB)
1382 assert(Rel.Symbol->isFunction());
1383 const MCSymbolWasm &WS = *ResolveSymbol(*Rel.Symbol);
1384 uint32_t FunctionIndex = WasmIndices.find(&WS)->second;
1385 uint32_t TableIndex = TableElems.size() + kInitialTableOffset;
1386 if (TableIndices.try_emplace(&WS, TableIndex).second) {
1387 LLVM_DEBUG(dbgs() << " -> adding " << WS.getName()
1388 << " to table: " << TableIndex << "\n");
1389 TableElems.push_back(FunctionIndex);
1390 registerFunctionType(WS);
1394 for (const WasmRelocationEntry &RelEntry : CodeRelocations)
1395 HandleReloc(RelEntry);
1396 for (const WasmRelocationEntry &RelEntry : DataRelocations)
1397 HandleReloc(RelEntry);
1400 // Translate .init_array section contents into start functions.
1401 for (const MCSection &S : Asm) {
1402 const auto &WS = static_cast<const MCSectionWasm &>(S);
1403 if (WS.getSectionName().startswith(".fini_array"))
1404 report_fatal_error(".fini_array sections are unsupported");
1405 if (!WS.getSectionName().startswith(".init_array"))
1407 if (WS.getFragmentList().empty())
1410 // init_array is expected to contain a single non-empty data fragment
1411 if (WS.getFragmentList().size() != 3)
1412 report_fatal_error("only one .init_array section fragment supported");
1414 auto IT = WS.begin();
1415 const MCFragment &EmptyFrag = *IT;
1416 if (EmptyFrag.getKind() != MCFragment::FT_Data)
1417 report_fatal_error(".init_array section should be aligned");
1420 const MCFragment &AlignFrag = *IT;
1421 if (AlignFrag.getKind() != MCFragment::FT_Align)
1422 report_fatal_error(".init_array section should be aligned");
1423 if (cast<MCAlignFragment>(AlignFrag).getAlignment() != (is64Bit() ? 8 : 4))
1424 report_fatal_error(".init_array section should be aligned for pointers");
1426 const MCFragment &Frag = *std::next(IT);
1427 if (Frag.hasInstructions() || Frag.getKind() != MCFragment::FT_Data)
1428 report_fatal_error("only data supported in .init_array section");
1430 uint16_t Priority = UINT16_MAX;
1431 unsigned PrefixLength = strlen(".init_array");
1432 if (WS.getSectionName().size() > PrefixLength) {
1433 if (WS.getSectionName()[PrefixLength] != '.')
1434 report_fatal_error(".init_array section priority should start with '.'");
1435 if (WS.getSectionName()
1436 .substr(PrefixLength + 1)
1437 .getAsInteger(10, Priority))
1438 report_fatal_error("invalid .init_array section priority");
1440 const auto &DataFrag = cast<MCDataFragment>(Frag);
1441 const SmallVectorImpl<char> &Contents = DataFrag.getContents();
1442 for (const uint8_t *p = (const uint8_t *)Contents.data(),
1443 *end = (const uint8_t *)Contents.data() + Contents.size();
1446 report_fatal_error("non-symbolic data in .init_array section");
1448 for (const MCFixup &Fixup : DataFrag.getFixups()) {
1449 assert(Fixup.getKind() == MCFixup::getKindForSize(is64Bit() ? 8 : 4, false));
1450 const MCExpr *Expr = Fixup.getValue();
1451 auto *Sym = dyn_cast<MCSymbolRefExpr>(Expr);
1453 report_fatal_error("fixups in .init_array should be symbol references");
1454 if (Sym->getKind() != MCSymbolRefExpr::VK_WebAssembly_FUNCTION)
1455 report_fatal_error("symbols in .init_array should be for functions");
1456 if (Sym->getSymbol().getIndex() == INVALID_INDEX)
1457 report_fatal_error("symbols in .init_array should exist in symbtab");
1458 InitFuncs.push_back(
1459 std::make_pair(Priority, Sym->getSymbol().getIndex()));
1463 // Write out the Wasm header.
1466 writeTypeSection(FunctionTypes);
1467 writeImportSection(Imports, DataSize, TableElems.size());
1468 writeFunctionSection(Functions);
1469 // Skip the "table" section; we import the table instead.
1470 // Skip the "memory" section; we import the memory instead.
1471 writeGlobalSection();
1472 writeExportSection(Exports);
1473 writeElemSection(TableElems);
1474 writeCodeSection(Asm, Layout, Functions);
1476 writeCustomSections(Asm, Layout);
1477 writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
1478 writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
1479 writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
1480 writeCustomRelocSections();
1482 // TODO: Translate the .comment section to the output.
1485 std::unique_ptr<MCObjectWriter>
1486 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
1487 raw_pwrite_stream &OS) {
1488 return llvm::make_unique<WasmObjectWriter>(std::move(MOTW), OS);