LLVM: lib/MC/WasmObjectWriter.cpp Source File

LLVM 22.0.0git
WasmObjectWriter.cpp
Go to the documentation of this file.
1//===- lib/MC/WasmObjectWriter.cpp - Wasm File Writer ---------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements Wasm object file writer information.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/STLExtras.h"
14#include "llvm/BinaryFormat/Wasm.h"
15#include "llvm/BinaryFormat/WasmTraits.h"
16#include "llvm/Config/llvm-config.h"
17#include "llvm/MC/MCAsmBackend.h"
18#include "llvm/MC/MCAssembler.h"
19#include "llvm/MC/MCContext.h"
20#include "llvm/MC/MCExpr.h"
21#include "llvm/MC/MCObjectWriter.h"
22#include "llvm/MC/MCSectionWasm.h"
23#include "llvm/MC/MCSymbolWasm.h"
24#include "llvm/MC/MCValue.h"
25#include "llvm/MC/MCWasmObjectWriter.h"
26#include "llvm/Support/Casting.h"
27#include "llvm/Support/Debug.h"
28#include "llvm/Support/EndianStream.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/LEB128.h"
31#include <vector>
32
33using namespace llvm;
34
35 #define DEBUG_TYPE "mc"
36
37namespace {
38
39// When we create the indirect function table we start at 1, so that there is
40// and empty slot at 0 and therefore calling a null function pointer will trap.
41static const uint32_t InitialTableOffset = 1;
42
43// For patching purposes, we need to remember where each section starts, both
44// for patching up the section size field, and for patching up references to
45// locations within the section.
46struct SectionBookkeeping {
47 // Where the size of the section is written.
48 uint64_t SizeOffset;
49 // Where the section header ends (without custom section name).
50 uint64_t PayloadOffset;
51 // Where the contents of the section starts.
52 uint64_t ContentsOffset;
53 uint32_t Index;
54};
55
56// A wasm data segment. A wasm binary contains only a single data section
57// but that can contain many segments, each with their own virtual location
58// in memory. Each MCSection data created by llvm is modeled as its own
59// wasm data segment.
60struct WasmDataSegment {
61 MCSectionWasm *Section;
62 StringRef Name;
63 uint32_t InitFlags;
64 uint64_t Offset;
65 uint32_t Alignment;
66 uint32_t LinkingFlags;
67 SmallVector<char, 4> Data;
68};
69
70// A wasm function to be written into the function section.
71struct WasmFunction {
72 uint32_t SigIndex;
73 MCSection *Section;
74};
75
76// A wasm global to be written into the global section.
77struct WasmGlobal {
78 wasm::WasmGlobalType Type;
79 uint64_t InitialValue;
80};
81
82// Information about a single item which is part of a COMDAT. For each data
83// segment or function which is in the COMDAT, there is a corresponding
84// WasmComdatEntry.
85struct WasmComdatEntry {
86 unsigned Kind;
87 uint32_t Index;
88};
89
90// Information about a single relocation.
91struct WasmRelocationEntry {
92 uint64_t Offset; // Where is the relocation.
93 const MCSymbolWasm *Symbol; // The symbol to relocate with.
94 int64_t Addend; // A value to add to the symbol.
95 unsigned Type; // The type of the relocation.
96 const MCSectionWasm *FixupSection; // The section the relocation is targeting.
97
98 WasmRelocationEntry(uint64_t Offset, const MCSymbolWasm *Symbol,
99 int64_t Addend, unsigned Type,
100 const MCSectionWasm *FixupSection)
101 : Offset(Offset), Symbol(Symbol), Addend(Addend), Type(Type),
102 FixupSection(FixupSection) {}
103
104 bool hasAddend() const { return wasm::relocTypeHasAddend(Type); }
105
106 void print(raw_ostream &Out) const {
107 Out << wasm::relocTypetoString(Type) << " Off=" << Offset
108 << ", Sym=" << *Symbol << ", Addend=" << Addend
109 << ", FixupSection=" << FixupSection->getName();
110 }
111
112#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
113 LLVM_DUMP_METHOD void dump() const { print(dbgs()); }
114#endif
115};
116
117static const uint32_t InvalidIndex = -1;
118
119struct WasmCustomSection {
120
121 StringRef Name;
122 MCSectionWasm *Section;
123
124 uint32_t OutputContentsOffset = 0;
125 uint32_t OutputIndex = InvalidIndex;
126
127 WasmCustomSection(StringRef Name, MCSectionWasm *Section)
128 : Name(Name), Section(Section) {}
129};
130
131#if !defined(NDEBUG)
132raw_ostream &operator<<(raw_ostream &OS, const WasmRelocationEntry &Rel) {
133 Rel.print(OS);
134 return OS;
135}
136#endif
137
138// Write Value as an (unsigned) LEB value at offset Offset in Stream, padded
139// to allow patching.
140template <typename T, int W>
141void writePatchableULEB(raw_pwrite_stream &Stream, T Value, uint64_t Offset) {
142 uint8_t Buffer[W];
143 unsigned SizeLen = encodeULEB128(Value, Buffer, W);
144 assert(SizeLen == W);
145 Stream.pwrite((char *)Buffer, SizeLen, Offset);
146}
147
148// Write Value as an signed LEB value at offset Offset in Stream, padded
149// to allow patching.
150template <typename T, int W>
151void writePatchableSLEB(raw_pwrite_stream &Stream, T Value, uint64_t Offset) {
152 uint8_t Buffer[W];
153 unsigned SizeLen = encodeSLEB128(Value, Buffer, W);
154 assert(SizeLen == W);
155 Stream.pwrite((char *)Buffer, SizeLen, Offset);
156}
157
158static void writePatchableU32(raw_pwrite_stream &Stream, uint32_t Value,
159 uint64_t Offset) {
160 writePatchableULEB<uint32_t, 5>(Stream, Value, Offset);
161}
162
163static void writePatchableS32(raw_pwrite_stream &Stream, int32_t Value,
164 uint64_t Offset) {
165 writePatchableSLEB<int32_t, 5>(Stream, Value, Offset);
166}
167
168static void writePatchableU64(raw_pwrite_stream &Stream, uint64_t Value,
169 uint64_t Offset) {
170 writePatchableSLEB<uint64_t, 10>(Stream, Value, Offset);
171}
172
173static void writePatchableS64(raw_pwrite_stream &Stream, int64_t Value,
174 uint64_t Offset) {
175 writePatchableSLEB<int64_t, 10>(Stream, Value, Offset);
176}
177
178// Write Value as a plain integer value at offset Offset in Stream.
179static void patchI32(raw_pwrite_stream &Stream, uint32_t Value,
180 uint64_t Offset) {
181 uint8_t Buffer[4];
182 support::endian::write32le(Buffer, Value);
183 Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
184}
185
186static void patchI64(raw_pwrite_stream &Stream, uint64_t Value,
187 uint64_t Offset) {
188 uint8_t Buffer[8];
189 support::endian::write64le(Buffer, Value);
190 Stream.pwrite((char *)Buffer, sizeof(Buffer), Offset);
191}
192
193bool isDwoSection(const MCSection &Sec) {
194 return Sec.getName().ends_with(".dwo");
195}
196
197class WasmObjectWriter : public MCObjectWriter {
198 support::endian::Writer *W = nullptr;
199
200 /// The target specific Wasm writer instance.
201 std::unique_ptr<MCWasmObjectTargetWriter> TargetObjectWriter;
202
203 // Relocations for fixing up references in the code section.
204 std::vector<WasmRelocationEntry> CodeRelocations;
205 // Relocations for fixing up references in the data section.
206 std::vector<WasmRelocationEntry> DataRelocations;
207
208 // Index values to use for fixing up call_indirect type indices.
209 // Maps function symbols to the index of the type of the function
210 DenseMap<const MCSymbolWasm *, uint32_t> TypeIndices;
211 // Maps function symbols to the table element index space. Used
212 // for TABLE_INDEX relocation types (i.e. address taken functions).
213 DenseMap<const MCSymbolWasm *, uint32_t> TableIndices;
214 // Maps function/global/table symbols to the
215 // function/global/table/tag/section index space.
216 DenseMap<const MCSymbolWasm *, uint32_t> WasmIndices;
217 DenseMap<const MCSymbolWasm *, uint32_t> GOTIndices;
218 // Maps data symbols to the Wasm segment and offset/size with the segment.
219 DenseMap<const MCSymbolWasm *, wasm::WasmDataReference> DataLocations;
220
221 // Stores output data (index, relocations, content offset) for custom
222 // section.
223 std::vector<WasmCustomSection> CustomSections;
224 std::unique_ptr<WasmCustomSection> ProducersSection;
225 std::unique_ptr<WasmCustomSection> TargetFeaturesSection;
226 // Relocations for fixing up references in the custom sections.
227 DenseMap<const MCSectionWasm *, std::vector<WasmRelocationEntry>>
228 CustomSectionsRelocations;
229
230 // Map from section to defining function symbol.
231 DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
232
233 DenseMap<wasm::WasmSignature, uint32_t> SignatureIndices;
234 SmallVector<wasm::WasmSignature, 4> Signatures;
235 SmallVector<WasmDataSegment, 4> DataSegments;
236 unsigned NumFunctionImports = 0;
237 unsigned NumGlobalImports = 0;
238 unsigned NumTableImports = 0;
239 unsigned NumTagImports = 0;
240 uint32_t SectionCount = 0;
241
242 enum class DwoMode {
243 AllSections,
244 NonDwoOnly,
245 DwoOnly,
246 };
247 bool IsSplitDwarf = false;
248 raw_pwrite_stream *OS = nullptr;
249 raw_pwrite_stream *DwoOS = nullptr;
250
251 // TargetObjectWriter wranppers.
252 bool is64Bit() const { return TargetObjectWriter->is64Bit(); }
253 bool isEmscripten() const { return TargetObjectWriter->isEmscripten(); }
254
255 void startSection(SectionBookkeeping &Section, unsigned SectionId);
256 void startCustomSection(SectionBookkeeping &Section, StringRef Name);
257 void endSection(SectionBookkeeping &Section);
258
259public:
260 WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
261 raw_pwrite_stream &OS_)
262 : TargetObjectWriter(std::move(MOTW)), OS(&OS_) {}
263
264 WasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
265 raw_pwrite_stream &OS_, raw_pwrite_stream &DwoOS_)
266 : TargetObjectWriter(std::move(MOTW)), IsSplitDwarf(true), OS(&OS_),
267 DwoOS(&DwoOS_) {}
268
269private:
270 void reset() override {
271 CodeRelocations.clear();
272 DataRelocations.clear();
273 TypeIndices.clear();
274 WasmIndices.clear();
275 GOTIndices.clear();
276 TableIndices.clear();
277 DataLocations.clear();
278 CustomSections.clear();
279 ProducersSection.reset();
280 TargetFeaturesSection.reset();
281 CustomSectionsRelocations.clear();
282 SignatureIndices.clear();
283 Signatures.clear();
284 DataSegments.clear();
285 SectionFunctions.clear();
286 NumFunctionImports = 0;
287 NumGlobalImports = 0;
288 NumTableImports = 0;
289 MCObjectWriter::reset();
290 }
291
292 void writeHeader(const MCAssembler &Asm);
293
294 void recordRelocation(const MCFragment &F, const MCFixup &Fixup,
295 MCValue Target, uint64_t &FixedValue) override;
296
297 void executePostLayoutBinding() override;
298 void prepareImports(SmallVectorImpl<wasm::WasmImport> &Imports,
299 MCAssembler &Asm);
300 uint64_t writeObject() override;
301
302 uint64_t writeOneObject(MCAssembler &Asm, DwoMode Mode);
303
304 void writeString(const StringRef Str) {
305 encodeULEB128(Str.size(), W->OS);
306 W->OS << Str;
307 }
308
309 void writeStringWithAlignment(const StringRef Str, unsigned Alignment);
310
311 void writeI32(int32_t val) {
312 char Buffer[4];
313 support::endian::write32le(Buffer, val);
314 W->OS.write(Buffer, sizeof(Buffer));
315 }
316
317 void writeI64(int64_t val) {
318 char Buffer[8];
319 support::endian::write64le(Buffer, val);
320 W->OS.write(Buffer, sizeof(Buffer));
321 }
322
323 void writeValueType(wasm::ValType Ty) { W->OS << static_cast<char>(Ty); }
324
325 void writeTypeSection(ArrayRef<wasm::WasmSignature> Signatures);
326 void writeImportSection(ArrayRef<wasm::WasmImport> Imports, uint64_t DataSize,
327 uint32_t NumElements);
328 void writeFunctionSection(ArrayRef<WasmFunction> Functions);
329 void writeExportSection(ArrayRef<wasm::WasmExport> Exports);
330 void writeElemSection(const MCSymbolWasm *IndirectFunctionTable,
331 ArrayRef<uint32_t> TableElems);
332 void writeDataCountSection();
333 uint32_t writeCodeSection(const MCAssembler &Asm,
334 ArrayRef<WasmFunction> Functions);
335 uint32_t writeDataSection(const MCAssembler &Asm);
336 void writeTagSection(ArrayRef<uint32_t> TagTypes);
337 void writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals);
338 void writeTableSection(ArrayRef<wasm::WasmTable> Tables);
339 void writeRelocSection(uint32_t SectionIndex, StringRef Name,
340 std::vector<WasmRelocationEntry> &Relocations);
341 void writeLinkingMetaDataSection(
342 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
343 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
344 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats);
345 void writeCustomSection(WasmCustomSection &CustomSection,
346 const MCAssembler &Asm);
347 void writeCustomRelocSections();
348
349 uint64_t getProvisionalValue(const MCAssembler &Asm,
350 const WasmRelocationEntry &RelEntry);
351 void applyRelocations(ArrayRef<WasmRelocationEntry> Relocations,
352 uint64_t ContentsOffset, const MCAssembler &Asm);
353
354 uint32_t getRelocationIndexValue(const WasmRelocationEntry &RelEntry);
355 uint32_t getFunctionType(const MCSymbolWasm &Symbol);
356 uint32_t getTagType(const MCSymbolWasm &Symbol);
357 void registerFunctionType(const MCSymbolWasm &Symbol);
358 void registerTagType(const MCSymbolWasm &Symbol);
359};
360
361} // end anonymous namespace
362
363// Write out a section header and a patchable section size field.
364void WasmObjectWriter::startSection(SectionBookkeeping &Section,
365 unsigned SectionId) {
366 LLVM_DEBUG(dbgs() << "startSection " << SectionId << "\n");
367 W->OS << char(SectionId);
368
369 Section.SizeOffset = W->OS.tell();
370
371 // The section size. We don't know the size yet, so reserve enough space
372 // for any 32-bit value; we'll patch it later.
373 encodeULEB128(0, W->OS, 5);
374
375 // The position where the section starts, for measuring its size.
376 Section.ContentsOffset = W->OS.tell();
377 Section.PayloadOffset = W->OS.tell();
378 Section.Index = SectionCount++;
379}
380
381// Write a string with extra paddings for trailing alignment
382// TODO: support alignment at asm and llvm level?
383void WasmObjectWriter::writeStringWithAlignment(const StringRef Str,
384 unsigned Alignment) {
385
386 // Calculate the encoded size of str length and add pads based on it and
387 // alignment.
388 raw_null_ostream NullOS;
389 uint64_t StrSizeLength = encodeULEB128(Str.size(), NullOS);
390 uint64_t Offset = W->OS.tell() + StrSizeLength + Str.size();
391 uint64_t Paddings = offsetToAlignment(Offset, Align(Alignment));
392 Offset += Paddings;
393
394 // LEB128 greater than 5 bytes is invalid
395 assert((StrSizeLength + Paddings) <= 5 && "too long string to align");
396
397 encodeSLEB128(Str.size(), W->OS, StrSizeLength + Paddings);
398 W->OS << Str;
399
400 assert(W->OS.tell() == Offset && "invalid padding");
401}
402
403void WasmObjectWriter::startCustomSection(SectionBookkeeping &Section,
404 StringRef Name) {
405 LLVM_DEBUG(dbgs() << "startCustomSection " << Name << "\n");
406 startSection(Section, wasm::WASM_SEC_CUSTOM);
407
408 // The position where the section header ends, for measuring its size.
409 Section.PayloadOffset = W->OS.tell();
410
411 // Custom sections in wasm also have a string identifier.
412 if (Name != "__clangast") {
413 writeString(Name);
414 } else {
415 // The on-disk hashtable in clangast needs to be aligned by 4 bytes.
416 writeStringWithAlignment(Name, 4);
417 }
418
419 // The position where the custom section starts.
420 Section.ContentsOffset = W->OS.tell();
421}
422
423// Now that the section is complete and we know how big it is, patch up the
424// section size field at the start of the section.
425void WasmObjectWriter::endSection(SectionBookkeeping &Section) {
426 uint64_t Size = W->OS.tell();
427 // /dev/null doesn't support seek/tell and can report offset of 0.
428 // Simply skip this patching in that case.
429 if (!Size)
430 return;
431
432 Size -= Section.PayloadOffset;
433 if (uint32_t(Size) != Size)
434 report_fatal_error("section size does not fit in a uint32_t");
435
436 LLVM_DEBUG(dbgs() << "endSection size=" << Size << "\n");
437
438 // Write the final section size to the payload_len field, which follows
439 // the section id byte.
440 writePatchableU32(static_cast<raw_pwrite_stream &>(W->OS), Size,
441 Section.SizeOffset);
442}
443
444// Emit the Wasm header.
445void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
446 W->OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
447 W->write<uint32_t>(wasm::WasmVersion);
448}
449
450void WasmObjectWriter::executePostLayoutBinding() {
451 // Some compilation units require the indirect function table to be present
452 // but don't explicitly reference it. This is the case for call_indirect
453 // without the reference-types feature, and also function bitcasts in all
454 // cases. In those cases the __indirect_function_table has the
455 // WASM_SYMBOL_NO_STRIP attribute. Here we make sure this symbol makes it to
456 // the assembler, if needed.
457 if (auto *Sym = Asm->getContext().lookupSymbol("__indirect_function_table")) {
458 const auto *WasmSym = static_cast<const MCSymbolWasm *>(Sym);
459 if (WasmSym->isNoStrip())
460 Asm->registerSymbol(*Sym);
461 }
462
463 // Build a map of sections to the function that defines them, for use
464 // in recordRelocation.
465 for (const MCSymbol &S : Asm->symbols()) {
466 const auto &WS = static_cast<const MCSymbolWasm &>(S);
467 if (WS.isDefined() && WS.isFunction() && !WS.isVariable()) {
468 const auto &Sec = static_cast<const MCSectionWasm &>(S.getSection());
469 auto Pair = SectionFunctions.insert(std::make_pair(&Sec, &S));
470 if (!Pair.second)
471 report_fatal_error("section already has a defining function: " +
472 Sec.getName());
473 }
474 }
475}
476
477void WasmObjectWriter::recordRelocation(const MCFragment &F,
478 const MCFixup &Fixup, MCValue Target,
479 uint64_t &FixedValue) {
480 // The WebAssembly backend should never generate FKF_IsPCRel fixups
481 assert(!Fixup.isPCRel());
482
483 const auto &FixupSection = static_cast<MCSectionWasm &>(*F.getParent());
484 uint64_t C = Target.getConstant();
485 uint64_t FixupOffset = Asm->getFragmentOffset(F) + Fixup.getOffset();
486 MCContext &Ctx = getContext();
487 bool IsLocRel = false;
488
489 if (const auto *RefB = Target.getSubSym()) {
490 auto &SymB = static_cast<const MCSymbolWasm &>(*RefB);
491
492 if (FixupSection.isText()) {
493 Ctx.reportError(Fixup.getLoc(),
494 Twine("symbol '") + SymB.getName() +
495 "' unsupported subtraction expression used in "
496 "relocation in code section.");
497 return;
498 }
499
500 if (SymB.isUndefined()) {
501 Ctx.reportError(Fixup.getLoc(),
502 Twine("symbol '") + SymB.getName() +
503 "' can not be undefined in a subtraction expression");
504 return;
505 }
506 const MCSection &SecB = SymB.getSection();
507 if (&SecB != &FixupSection) {
508 Ctx.reportError(Fixup.getLoc(),
509 Twine("symbol '") + SymB.getName() +
510 "' can not be placed in a different section");
511 return;
512 }
513 IsLocRel = true;
514 C += FixupOffset - Asm->getSymbolOffset(SymB);
515 }
516
517 // We either rejected the fixup or folded B into C at this point.
518 auto *SymA = static_cast<const MCSymbolWasm *>(Target.getAddSym());
519
520 // The .init_array isn't translated as data, so don't do relocations in it.
521 if (FixupSection.getName().starts_with(".init_array")) {
522 SymA->setUsedInInitArray();
523 return;
524 }
525
526 // Put any constant offset in an addend. Offsets can be negative, and
527 // LLVM expects wrapping, in contrast to wasm's immediates which can't
528 // be negative and don't wrap.
529 FixedValue = 0;
530
531 unsigned Type;
532 if (mc::isRelocRelocation(Fixup.getKind()))
533 Type = Fixup.getKind() - FirstLiteralRelocationKind;
534 else
535 Type =
536 TargetObjectWriter->getRelocType(Target, Fixup, FixupSection, IsLocRel);
537
538 // Absolute offset within a section or a function.
539 // Currently only supported for metadata sections.
540 // See: test/MC/WebAssembly/blockaddress.ll
541 if ((Type == wasm::R_WASM_FUNCTION_OFFSET_I32 ||
542 Type == wasm::R_WASM_FUNCTION_OFFSET_I64 ||
543 Type == wasm::R_WASM_SECTION_OFFSET_I32) &&
544 SymA->isDefined()) {
545 // SymA can be a temp data symbol that represents a function (in which case
546 // it needs to be replaced by the section symbol), [XXX and it apparently
547 // later gets changed again to a func symbol?] or it can be a real
548 // function symbol, in which case it can be left as-is.
549
550 if (!FixupSection.isMetadata())
551 report_fatal_error("relocations for function or section offsets are "
552 "only supported in metadata sections");
553
554 const MCSymbol *SectionSymbol = nullptr;
555 const MCSection &SecA = SymA->getSection();
556 if (SecA.isText()) {
557 auto SecSymIt = SectionFunctions.find(&SecA);
558 if (SecSymIt == SectionFunctions.end())
559 report_fatal_error("section doesn\'t have defining symbol");
560 SectionSymbol = SecSymIt->second;
561 } else {
562 SectionSymbol = SecA.getBeginSymbol();
563 }
564 if (!SectionSymbol)
565 report_fatal_error("section symbol is required for relocation");
566
567 C += Asm->getSymbolOffset(*SymA);
568 SymA = static_cast<const MCSymbolWasm *>(SectionSymbol);
569 }
570
571 if (Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB ||
572 Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB64 ||
573 Type == wasm::R_WASM_TABLE_INDEX_SLEB ||
574 Type == wasm::R_WASM_TABLE_INDEX_SLEB64 ||
575 Type == wasm::R_WASM_TABLE_INDEX_I32 ||
576 Type == wasm::R_WASM_TABLE_INDEX_I64) {
577 // TABLE_INDEX relocs implicitly use the default indirect function table.
578 // We require the function table to have already been defined.
579 auto TableName = "__indirect_function_table";
580 auto *Sym = static_cast<MCSymbolWasm *>(Ctx.lookupSymbol(TableName));
581 if (!Sym) {
582 report_fatal_error("missing indirect function table symbol");
583 } else {
584 if (!Sym->isFunctionTable())
585 report_fatal_error("__indirect_function_table symbol has wrong type");
586 // Ensure that __indirect_function_table reaches the output.
587 Sym->setNoStrip();
588 Asm->registerSymbol(*Sym);
589 }
590 }
591
592 // Relocation other than R_WASM_TYPE_INDEX_LEB are required to be
593 // against a named symbol.
594 if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
595 if (SymA->getName().empty())
596 report_fatal_error("relocations against un-named temporaries are not yet "
597 "supported by wasm");
598
599 SymA->setUsedInReloc();
600 }
601
602 WasmRelocationEntry Rec(FixupOffset, SymA, C, Type, &FixupSection);
603 LLVM_DEBUG(dbgs() << "WasmReloc: " << Rec << "\n");
604
605 if (FixupSection.isWasmData()) {
606 DataRelocations.push_back(Rec);
607 } else if (FixupSection.isText()) {
608 CodeRelocations.push_back(Rec);
609 } else if (FixupSection.isMetadata()) {
610 CustomSectionsRelocations[&FixupSection].push_back(Rec);
611 } else {
612 llvm_unreachable("unexpected section type");
613 }
614}
615
616// Compute a value to write into the code at the location covered
617// by RelEntry. This value isn't used by the static linker; it just serves
618// to make the object format more readable and more likely to be directly
619// useable.
620uint64_t
621WasmObjectWriter::getProvisionalValue(const MCAssembler &Asm,
622 const WasmRelocationEntry &RelEntry) {
623 if ((RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_LEB ||
624 RelEntry.Type == wasm::R_WASM_GLOBAL_INDEX_I32) &&
625 !RelEntry.Symbol->isGlobal()) {
626 assert(GOTIndices.count(RelEntry.Symbol) > 0 && "symbol not found in GOT index space");
627 return GOTIndices[RelEntry.Symbol];
628 }
629
630 switch (RelEntry.Type) {
631 case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
632 case wasm::R_WASM_TABLE_INDEX_REL_SLEB64:
633 case wasm::R_WASM_TABLE_INDEX_SLEB:
634 case wasm::R_WASM_TABLE_INDEX_SLEB64:
635 case wasm::R_WASM_TABLE_INDEX_I32:
636 case wasm::R_WASM_TABLE_INDEX_I64: {
637 // Provisional value is table address of the resolved symbol itself
638 auto *Base =
639 static_cast<const MCSymbolWasm *>(Asm.getBaseSymbol(*RelEntry.Symbol));
640 assert(Base->isFunction());
641 if (RelEntry.Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB ||
642 RelEntry.Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB64)
643 return TableIndices[Base] - InitialTableOffset;
644 else
645 return TableIndices[Base];
646 }
647 case wasm::R_WASM_TYPE_INDEX_LEB:
648 // Provisional value is same as the index
649 return getRelocationIndexValue(RelEntry);
650 case wasm::R_WASM_FUNCTION_INDEX_LEB:
651 case wasm::R_WASM_FUNCTION_INDEX_I32:
652 case wasm::R_WASM_GLOBAL_INDEX_LEB:
653 case wasm::R_WASM_GLOBAL_INDEX_I32:
654 case wasm::R_WASM_TAG_INDEX_LEB:
655 case wasm::R_WASM_TABLE_NUMBER_LEB:
656 // Provisional value is function/global/tag Wasm index
657 assert(WasmIndices.count(RelEntry.Symbol) > 0 && "symbol not found in wasm index space");
658 return WasmIndices[RelEntry.Symbol];
659 case wasm::R_WASM_FUNCTION_OFFSET_I32:
660 case wasm::R_WASM_FUNCTION_OFFSET_I64:
661 case wasm::R_WASM_SECTION_OFFSET_I32: {
662 if (!RelEntry.Symbol->isDefined())
663 return 0;
664 const auto &Section =
665 static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
666 return Section.getSectionOffset() + RelEntry.Addend;
667 }
668 case wasm::R_WASM_MEMORY_ADDR_LEB:
669 case wasm::R_WASM_MEMORY_ADDR_LEB64:
670 case wasm::R_WASM_MEMORY_ADDR_SLEB:
671 case wasm::R_WASM_MEMORY_ADDR_SLEB64:
672 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
673 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
674 case wasm::R_WASM_MEMORY_ADDR_I32:
675 case wasm::R_WASM_MEMORY_ADDR_I64:
676 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
677 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64:
678 case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32: {
679 // Provisional value is address of the global plus the offset
680 // For undefined symbols, use zero
681 if (!RelEntry.Symbol->isDefined())
682 return 0;
683 const wasm::WasmDataReference &SymRef = DataLocations[RelEntry.Symbol];
684 const WasmDataSegment &Segment = DataSegments[SymRef.Segment];
685 // Ignore overflow. LLVM allows address arithmetic to silently wrap.
686 return Segment.Offset + SymRef.Offset + RelEntry.Addend;
687 }
688 default:
689 llvm_unreachable("invalid relocation type");
690 }
691}
692
693 static void addData(SmallVectorImpl<char> &DataBytes,
694 MCSectionWasm &DataSection) {
695 LLVM_DEBUG(errs() << "addData: " << DataSection.getName() << "\n");
696
697 DataBytes.resize(alignTo(DataBytes.size(), DataSection.getAlign()));
698
699 for (const MCFragment &Frag : DataSection) {
700 if (Frag.hasInstructions())
701 report_fatal_error("only data supported in data sections");
702
703 llvm::append_range(DataBytes, Frag.getContents());
704 if (Frag.getKind() == MCFragment::FT_Align) {
705 if (Frag.getAlignFillLen() != 1)
706 report_fatal_error("only byte values supported for alignment");
707 // If nops are requested, use zeros, as this is the data section.
708 uint8_t Value = Frag.hasAlignEmitNops() ? 0 : Frag.getAlignFill();
709 uint64_t Size =
710 std::min<uint64_t>(alignTo(DataBytes.size(), Frag.getAlignment()),
711 DataBytes.size() + Frag.getAlignMaxBytesToEmit());
712 DataBytes.resize(Size, Value);
713 } else if (auto *Fill = dyn_cast<MCFillFragment>(&Frag)) {
714 int64_t NumValues;
715 if (!Fill->getNumValues().evaluateAsAbsolute(NumValues))
716 llvm_unreachable("The fill should be an assembler constant");
717 DataBytes.insert(DataBytes.end(), Fill->getValueSize() * NumValues,
718 Fill->getValue());
719 } else if (Frag.getKind() == MCFragment::FT_LEB) {
720 llvm::append_range(DataBytes, Frag.getVarContents());
721 } else {
722 assert(Frag.getKind() == MCFragment::FT_Data);
723 }
724 }
725
726 LLVM_DEBUG(dbgs() << "addData -> " << DataBytes.size() << "\n");
727}
728
729uint32_t
730WasmObjectWriter::getRelocationIndexValue(const WasmRelocationEntry &RelEntry) {
731 if (RelEntry.Type == wasm::R_WASM_TYPE_INDEX_LEB) {
732 auto It = TypeIndices.find(RelEntry.Symbol);
733 if (It == TypeIndices.end())
734 report_fatal_error("symbol not found in type index space: " +
735 RelEntry.Symbol->getName());
736 return It->second;
737 }
738
739 return RelEntry.Symbol->getIndex();
740}
741
742// Apply the portions of the relocation records that we can handle ourselves
743// directly.
744void WasmObjectWriter::applyRelocations(
745 ArrayRef<WasmRelocationEntry> Relocations, uint64_t ContentsOffset,
746 const MCAssembler &Asm) {
747 auto &Stream = static_cast<raw_pwrite_stream &>(W->OS);
748 for (const WasmRelocationEntry &RelEntry : Relocations) {
749 uint64_t Offset = ContentsOffset +
750 RelEntry.FixupSection->getSectionOffset() +
751 RelEntry.Offset;
752
753 LLVM_DEBUG(dbgs() << "applyRelocation: " << RelEntry << "\n");
754 uint64_t Value = getProvisionalValue(Asm, RelEntry);
755
756 switch (RelEntry.Type) {
757 case wasm::R_WASM_FUNCTION_INDEX_LEB:
758 case wasm::R_WASM_TYPE_INDEX_LEB:
759 case wasm::R_WASM_GLOBAL_INDEX_LEB:
760 case wasm::R_WASM_MEMORY_ADDR_LEB:
761 case wasm::R_WASM_TAG_INDEX_LEB:
762 case wasm::R_WASM_TABLE_NUMBER_LEB:
763 writePatchableU32(Stream, Value, Offset);
764 break;
765 case wasm::R_WASM_MEMORY_ADDR_LEB64:
766 writePatchableU64(Stream, Value, Offset);
767 break;
768 case wasm::R_WASM_TABLE_INDEX_I32:
769 case wasm::R_WASM_MEMORY_ADDR_I32:
770 case wasm::R_WASM_FUNCTION_OFFSET_I32:
771 case wasm::R_WASM_FUNCTION_INDEX_I32:
772 case wasm::R_WASM_SECTION_OFFSET_I32:
773 case wasm::R_WASM_GLOBAL_INDEX_I32:
774 case wasm::R_WASM_MEMORY_ADDR_LOCREL_I32:
775 patchI32(Stream, Value, Offset);
776 break;
777 case wasm::R_WASM_TABLE_INDEX_I64:
778 case wasm::R_WASM_MEMORY_ADDR_I64:
779 case wasm::R_WASM_FUNCTION_OFFSET_I64:
780 patchI64(Stream, Value, Offset);
781 break;
782 case wasm::R_WASM_TABLE_INDEX_SLEB:
783 case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
784 case wasm::R_WASM_MEMORY_ADDR_SLEB:
785 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB:
786 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB:
787 writePatchableS32(Stream, Value, Offset);
788 break;
789 case wasm::R_WASM_TABLE_INDEX_SLEB64:
790 case wasm::R_WASM_TABLE_INDEX_REL_SLEB64:
791 case wasm::R_WASM_MEMORY_ADDR_SLEB64:
792 case wasm::R_WASM_MEMORY_ADDR_REL_SLEB64:
793 case wasm::R_WASM_MEMORY_ADDR_TLS_SLEB64:
794 writePatchableS64(Stream, Value, Offset);
795 break;
796 default:
797 llvm_unreachable("invalid relocation type");
798 }
799 }
800}
801
802void WasmObjectWriter::writeTypeSection(
803 ArrayRef<wasm::WasmSignature> Signatures) {
804 if (Signatures.empty())
805 return;
806
807 SectionBookkeeping Section;
808 startSection(Section, wasm::WASM_SEC_TYPE);
809
810 encodeULEB128(Signatures.size(), W->OS);
811
812 for (const wasm::WasmSignature &Sig : Signatures) {
813 W->OS << char(wasm::WASM_TYPE_FUNC);
814 encodeULEB128(Sig.Params.size(), W->OS);
815 for (wasm::ValType Ty : Sig.Params)
816 writeValueType(Ty);
817 encodeULEB128(Sig.Returns.size(), W->OS);
818 for (wasm::ValType Ty : Sig.Returns)
819 writeValueType(Ty);
820 }
821
822 endSection(Section);
823}
824
825void WasmObjectWriter::writeImportSection(ArrayRef<wasm::WasmImport> Imports,
826 uint64_t DataSize,
827 uint32_t NumElements) {
828 if (Imports.empty())
829 return;
830
831 uint64_t NumPages =
832 (DataSize + wasm::WasmDefaultPageSize - 1) / wasm::WasmDefaultPageSize;
833
834 SectionBookkeeping Section;
835 startSection(Section, wasm::WASM_SEC_IMPORT);
836
837 encodeULEB128(Imports.size(), W->OS);
838 for (const wasm::WasmImport &Import : Imports) {
839 writeString(Import.Module);
840 writeString(Import.Field);
841 W->OS << char(Import.Kind);
842
843 switch (Import.Kind) {
844 case wasm::WASM_EXTERNAL_FUNCTION:
845 encodeULEB128(Import.SigIndex, W->OS);
846 break;
847 case wasm::WASM_EXTERNAL_GLOBAL:
848 W->OS << char(Import.Global.Type);
849 W->OS << char(Import.Global.Mutable ? 1 : 0);
850 break;
851 case wasm::WASM_EXTERNAL_MEMORY:
852 encodeULEB128(Import.Memory.Flags, W->OS);
853 encodeULEB128(NumPages, W->OS); // initial
854 break;
855 case wasm::WASM_EXTERNAL_TABLE:
856 W->OS << char(Import.Table.ElemType);
857 encodeULEB128(Import.Table.Limits.Flags, W->OS);
858 encodeULEB128(NumElements, W->OS); // initial
859 break;
860 case wasm::WASM_EXTERNAL_TAG:
861 W->OS << char(0); // Reserved 'attribute' field
862 encodeULEB128(Import.SigIndex, W->OS);
863 break;
864 default:
865 llvm_unreachable("unsupported import kind");
866 }
867 }
868
869 endSection(Section);
870}
871
872void WasmObjectWriter::writeFunctionSection(ArrayRef<WasmFunction> Functions) {
873 if (Functions.empty())
874 return;
875
876 SectionBookkeeping Section;
877 startSection(Section, wasm::WASM_SEC_FUNCTION);
878
879 encodeULEB128(Functions.size(), W->OS);
880 for (const WasmFunction &Func : Functions)
881 encodeULEB128(Func.SigIndex, W->OS);
882
883 endSection(Section);
884}
885
886void WasmObjectWriter::writeTagSection(ArrayRef<uint32_t> TagTypes) {
887 if (TagTypes.empty())
888 return;
889
890 SectionBookkeeping Section;
891 startSection(Section, wasm::WASM_SEC_TAG);
892
893 encodeULEB128(TagTypes.size(), W->OS);
894 for (uint32_t Index : TagTypes) {
895 W->OS << char(0); // Reserved 'attribute' field
896 encodeULEB128(Index, W->OS);
897 }
898
899 endSection(Section);
900}
901
902void WasmObjectWriter::writeGlobalSection(ArrayRef<wasm::WasmGlobal> Globals) {
903 if (Globals.empty())
904 return;
905
906 SectionBookkeeping Section;
907 startSection(Section, wasm::WASM_SEC_GLOBAL);
908
909 encodeULEB128(Globals.size(), W->OS);
910 for (const wasm::WasmGlobal &Global : Globals) {
911 encodeULEB128(Global.Type.Type, W->OS);
912 W->OS << char(Global.Type.Mutable);
913 if (Global.InitExpr.Extended) {
914 llvm_unreachable("extected init expressions not supported");
915 } else {
916 W->OS << char(Global.InitExpr.Inst.Opcode);
917 switch (Global.Type.Type) {
918 case wasm::WASM_TYPE_I32:
919 encodeSLEB128(0, W->OS);
920 break;
921 case wasm::WASM_TYPE_I64:
922 encodeSLEB128(0, W->OS);
923 break;
924 case wasm::WASM_TYPE_F32:
925 writeI32(0);
926 break;
927 case wasm::WASM_TYPE_F64:
928 writeI64(0);
929 break;
930 case wasm::WASM_TYPE_EXTERNREF:
931 writeValueType(wasm::ValType::EXTERNREF);
932 break;
933 default:
934 llvm_unreachable("unexpected type");
935 }
936 }
937 W->OS << char(wasm::WASM_OPCODE_END);
938 }
939
940 endSection(Section);
941}
942
943void WasmObjectWriter::writeTableSection(ArrayRef<wasm::WasmTable> Tables) {
944 if (Tables.empty())
945 return;
946
947 SectionBookkeeping Section;
948 startSection(Section, wasm::WASM_SEC_TABLE);
949
950 encodeULEB128(Tables.size(), W->OS);
951 for (const wasm::WasmTable &Table : Tables) {
952 assert(Table.Type.ElemType != wasm::ValType::OTHERREF &&
953 "Cannot encode general ref-typed tables");
954 encodeULEB128((uint32_t)Table.Type.ElemType, W->OS);
955 encodeULEB128(Table.Type.Limits.Flags, W->OS);
956 encodeULEB128(Table.Type.Limits.Minimum, W->OS);
957 if (Table.Type.Limits.Flags & wasm::WASM_LIMITS_FLAG_HAS_MAX)
958 encodeULEB128(Table.Type.Limits.Maximum, W->OS);
959 }
960 endSection(Section);
961}
962
963void WasmObjectWriter::writeExportSection(ArrayRef<wasm::WasmExport> Exports) {
964 if (Exports.empty())
965 return;
966
967 SectionBookkeeping Section;
968 startSection(Section, wasm::WASM_SEC_EXPORT);
969
970 encodeULEB128(Exports.size(), W->OS);
971 for (const wasm::WasmExport &Export : Exports) {
972 writeString(Export.Name);
973 W->OS << char(Export.Kind);
974 encodeULEB128(Export.Index, W->OS);
975 }
976
977 endSection(Section);
978}
979
980void WasmObjectWriter::writeElemSection(
981 const MCSymbolWasm *IndirectFunctionTable, ArrayRef<uint32_t> TableElems) {
982 if (TableElems.empty())
983 return;
984
985 assert(IndirectFunctionTable);
986
987 SectionBookkeeping Section;
988 startSection(Section, wasm::WASM_SEC_ELEM);
989
990 encodeULEB128(1, W->OS); // number of "segments"
991
992 assert(WasmIndices.count(IndirectFunctionTable));
993 uint32_t TableNumber = WasmIndices.find(IndirectFunctionTable)->second;
994 uint32_t Flags = 0;
995 if (TableNumber)
996 Flags |= wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER;
997 encodeULEB128(Flags, W->OS);
998 if (Flags & wasm::WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER)
999 encodeULEB128(TableNumber, W->OS); // the table number
1000
1001 // init expr for starting offset
1002 W->OS << char(is64Bit() ? wasm::WASM_OPCODE_I64_CONST
1003 : wasm::WASM_OPCODE_I32_CONST);
1004 encodeSLEB128(InitialTableOffset, W->OS);
1005 W->OS << char(wasm::WASM_OPCODE_END);
1006
1007 if (Flags & wasm::WASM_ELEM_SEGMENT_MASK_HAS_ELEM_DESC) {
1008 // We only write active function table initializers, for which the elem kind
1009 // is specified to be written as 0x00 and interpreted to mean "funcref".
1010 const uint8_t ElemKind = 0;
1011 W->OS << ElemKind;
1012 }
1013
1014 encodeULEB128(TableElems.size(), W->OS);
1015 for (uint32_t Elem : TableElems)
1016 encodeULEB128(Elem, W->OS);
1017
1018 endSection(Section);
1019}
1020
1021void WasmObjectWriter::writeDataCountSection() {
1022 if (DataSegments.empty())
1023 return;
1024
1025 SectionBookkeeping Section;
1026 startSection(Section, wasm::WASM_SEC_DATACOUNT);
1027 encodeULEB128(DataSegments.size(), W->OS);
1028 endSection(Section);
1029}
1030
1031uint32_t WasmObjectWriter::writeCodeSection(const MCAssembler &Asm,
1032 ArrayRef<WasmFunction> Functions) {
1033 if (Functions.empty())
1034 return 0;
1035
1036 SectionBookkeeping Section;
1037 startSection(Section, wasm::WASM_SEC_CODE);
1038
1039 encodeULEB128(Functions.size(), W->OS);
1040
1041 for (const WasmFunction &Func : Functions) {
1042 auto *FuncSection = static_cast<MCSectionWasm *>(Func.Section);
1043
1044 int64_t Size = Asm.getSectionAddressSize(*FuncSection);
1045 encodeULEB128(Size, W->OS);
1046 FuncSection->setSectionOffset(W->OS.tell() - Section.ContentsOffset);
1047 Asm.writeSectionData(W->OS, FuncSection);
1048 }
1049
1050 // Apply fixups.
1051 applyRelocations(CodeRelocations, Section.ContentsOffset, Asm);
1052
1053 endSection(Section);
1054 return Section.Index;
1055}
1056
1057uint32_t WasmObjectWriter::writeDataSection(const MCAssembler &Asm) {
1058 if (DataSegments.empty())
1059 return 0;
1060
1061 SectionBookkeeping Section;
1062 startSection(Section, wasm::WASM_SEC_DATA);
1063
1064 encodeULEB128(DataSegments.size(), W->OS); // count
1065
1066 for (const WasmDataSegment &Segment : DataSegments) {
1067 encodeULEB128(Segment.InitFlags, W->OS); // flags
1068 if (Segment.InitFlags & wasm::WASM_DATA_SEGMENT_HAS_MEMINDEX)
1069 encodeULEB128(0, W->OS); // memory index
1070 if ((Segment.InitFlags & wasm::WASM_DATA_SEGMENT_IS_PASSIVE) == 0) {
1071 W->OS << char(is64Bit() ? wasm::WASM_OPCODE_I64_CONST
1072 : wasm::WASM_OPCODE_I32_CONST);
1073 encodeSLEB128(Segment.Offset, W->OS); // offset
1074 W->OS << char(wasm::WASM_OPCODE_END);
1075 }
1076 encodeULEB128(Segment.Data.size(), W->OS); // size
1077 Segment.Section->setSectionOffset(W->OS.tell() - Section.ContentsOffset);
1078 W->OS << Segment.Data; // data
1079 }
1080
1081 // Apply fixups.
1082 applyRelocations(DataRelocations, Section.ContentsOffset, Asm);
1083
1084 endSection(Section);
1085 return Section.Index;
1086}
1087
1088void WasmObjectWriter::writeRelocSection(
1089 uint32_t SectionIndex, StringRef Name,
1090 std::vector<WasmRelocationEntry> &Relocs) {
1091 // See: https://github.com/WebAssembly/tool-conventions/blob/main/Linking.md
1092 // for descriptions of the reloc sections.
1093
1094 if (Relocs.empty())
1095 return;
1096
1097 // First, ensure the relocations are sorted in offset order. In general they
1098 // should already be sorted since `recordRelocation` is called in offset
1099 // order, but for the code section we combine many MC sections into single
1100 // wasm section, and this order is determined by the order of Asm.Symbols()
1101 // not the sections order.
1102 llvm::stable_sort(
1103 Relocs, [](const WasmRelocationEntry &A, const WasmRelocationEntry &B) {
1104 return (A.Offset + A.FixupSection->getSectionOffset()) <
1105 (B.Offset + B.FixupSection->getSectionOffset());
1106 });
1107
1108 SectionBookkeeping Section;
1109 startCustomSection(Section, std::string("reloc.") + Name.str());
1110
1111 encodeULEB128(SectionIndex, W->OS);
1112 encodeULEB128(Relocs.size(), W->OS);
1113 for (const WasmRelocationEntry &RelEntry : Relocs) {
1114 uint64_t Offset =
1115 RelEntry.Offset + RelEntry.FixupSection->getSectionOffset();
1116 uint32_t Index = getRelocationIndexValue(RelEntry);
1117
1118 W->OS << char(RelEntry.Type);
1119 encodeULEB128(Offset, W->OS);
1120 encodeULEB128(Index, W->OS);
1121 if (RelEntry.hasAddend())
1122 encodeSLEB128(RelEntry.Addend, W->OS);
1123 }
1124
1125 endSection(Section);
1126}
1127
1128void WasmObjectWriter::writeCustomRelocSections() {
1129 for (const auto &Sec : CustomSections) {
1130 auto &Relocations = CustomSectionsRelocations[Sec.Section];
1131 writeRelocSection(Sec.OutputIndex, Sec.Name, Relocations);
1132 }
1133}
1134
1135void WasmObjectWriter::writeLinkingMetaDataSection(
1136 ArrayRef<wasm::WasmSymbolInfo> SymbolInfos,
1137 ArrayRef<std::pair<uint16_t, uint32_t>> InitFuncs,
1138 const std::map<StringRef, std::vector<WasmComdatEntry>> &Comdats) {
1139 SectionBookkeeping Section;
1140 startCustomSection(Section, "linking");
1141 encodeULEB128(wasm::WasmMetadataVersion, W->OS);
1142
1143 SectionBookkeeping SubSection;
1144 if (SymbolInfos.size() != 0) {
1145 startSection(SubSection, wasm::WASM_SYMBOL_TABLE);
1146 encodeULEB128(SymbolInfos.size(), W->OS);
1147 for (const wasm::WasmSymbolInfo &Sym : SymbolInfos) {
1148 encodeULEB128(Sym.Kind, W->OS);
1149 encodeULEB128(Sym.Flags, W->OS);
1150 switch (Sym.Kind) {
1151 case wasm::WASM_SYMBOL_TYPE_FUNCTION:
1152 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
1153 case wasm::WASM_SYMBOL_TYPE_TAG:
1154 case wasm::WASM_SYMBOL_TYPE_TABLE:
1155 encodeULEB128(Sym.ElementIndex, W->OS);
1156 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0 ||
1157 (Sym.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0)
1158 writeString(Sym.Name);
1159 break;
1160 case wasm::WASM_SYMBOL_TYPE_DATA:
1161 writeString(Sym.Name);
1162 if ((Sym.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0) {
1163 encodeULEB128(Sym.DataRef.Segment, W->OS);
1164 encodeULEB128(Sym.DataRef.Offset, W->OS);
1165 encodeULEB128(Sym.DataRef.Size, W->OS);
1166 }
1167 break;
1168 case wasm::WASM_SYMBOL_TYPE_SECTION: {
1169 const uint32_t SectionIndex =
1170 CustomSections[Sym.ElementIndex].OutputIndex;
1171 encodeULEB128(SectionIndex, W->OS);
1172 break;
1173 }
1174 default:
1175 llvm_unreachable("unexpected kind");
1176 }
1177 }
1178 endSection(SubSection);
1179 }
1180
1181 if (DataSegments.size()) {
1182 startSection(SubSection, wasm::WASM_SEGMENT_INFO);
1183 encodeULEB128(DataSegments.size(), W->OS);
1184 for (const WasmDataSegment &Segment : DataSegments) {
1185 writeString(Segment.Name);
1186 encodeULEB128(Segment.Alignment, W->OS);
1187 encodeULEB128(Segment.LinkingFlags, W->OS);
1188 }
1189 endSection(SubSection);
1190 }
1191
1192 if (!InitFuncs.empty()) {
1193 startSection(SubSection, wasm::WASM_INIT_FUNCS);
1194 encodeULEB128(InitFuncs.size(), W->OS);
1195 for (auto &StartFunc : InitFuncs) {
1196 encodeULEB128(StartFunc.first, W->OS); // priority
1197 encodeULEB128(StartFunc.second, W->OS); // function index
1198 }
1199 endSection(SubSection);
1200 }
1201
1202 if (Comdats.size()) {
1203 startSection(SubSection, wasm::WASM_COMDAT_INFO);
1204 encodeULEB128(Comdats.size(), W->OS);
1205 for (const auto &C : Comdats) {
1206 writeString(C.first);
1207 encodeULEB128(0, W->OS); // flags for future use
1208 encodeULEB128(C.second.size(), W->OS);
1209 for (const WasmComdatEntry &Entry : C.second) {
1210 encodeULEB128(Entry.Kind, W->OS);
1211 encodeULEB128(Entry.Index, W->OS);
1212 }
1213 }
1214 endSection(SubSection);
1215 }
1216
1217 endSection(Section);
1218}
1219
1220void WasmObjectWriter::writeCustomSection(WasmCustomSection &CustomSection,
1221 const MCAssembler &Asm) {
1222 SectionBookkeeping Section;
1223 auto *Sec = CustomSection.Section;
1224 startCustomSection(Section, CustomSection.Name);
1225
1226 Sec->setSectionOffset(W->OS.tell() - Section.ContentsOffset);
1227 Asm.writeSectionData(W->OS, Sec);
1228
1229 CustomSection.OutputContentsOffset = Section.ContentsOffset;
1230 CustomSection.OutputIndex = Section.Index;
1231
1232 endSection(Section);
1233
1234 // Apply fixups.
1235 auto &Relocations = CustomSectionsRelocations[CustomSection.Section];
1236 applyRelocations(Relocations, CustomSection.OutputContentsOffset, Asm);
1237}
1238
1239uint32_t WasmObjectWriter::getFunctionType(const MCSymbolWasm &Symbol) {
1240 assert(Symbol.isFunction());
1241 assert(TypeIndices.count(&Symbol));
1242 return TypeIndices[&Symbol];
1243}
1244
1245uint32_t WasmObjectWriter::getTagType(const MCSymbolWasm &Symbol) {
1246 assert(Symbol.isTag());
1247 assert(TypeIndices.count(&Symbol));
1248 return TypeIndices[&Symbol];
1249}
1250
1251void WasmObjectWriter::registerFunctionType(const MCSymbolWasm &Symbol) {
1252 assert(Symbol.isFunction());
1253
1254 wasm::WasmSignature S;
1255
1256 if (auto *Sig = Symbol.getSignature()) {
1257 S.Returns = Sig->Returns;
1258 S.Params = Sig->Params;
1259 }
1260
1261 auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
1262 if (Pair.second)
1263 Signatures.push_back(S);
1264 TypeIndices[&Symbol] = Pair.first->second;
1265
1266 LLVM_DEBUG(dbgs() << "registerFunctionType: " << Symbol
1267 << " new:" << Pair.second << "\n");
1268 LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
1269}
1270
1271void WasmObjectWriter::registerTagType(const MCSymbolWasm &Symbol) {
1272 assert(Symbol.isTag());
1273
1274 // TODO Currently we don't generate imported exceptions, but if we do, we
1275 // should have a way of infering types of imported exceptions.
1276 wasm::WasmSignature S;
1277 if (auto *Sig = Symbol.getSignature()) {
1278 S.Returns = Sig->Returns;
1279 S.Params = Sig->Params;
1280 }
1281
1282 auto Pair = SignatureIndices.insert(std::make_pair(S, Signatures.size()));
1283 if (Pair.second)
1284 Signatures.push_back(S);
1285 TypeIndices[&Symbol] = Pair.first->second;
1286
1287 LLVM_DEBUG(dbgs() << "registerTagType: " << Symbol << " new:" << Pair.second
1288 << "\n");
1289 LLVM_DEBUG(dbgs() << " -> type index: " << Pair.first->second << "\n");
1290}
1291
1292 static bool isInSymtab(const MCSymbolWasm &Sym) {
1293 if (Sym.isUsedInReloc() || Sym.isUsedInInitArray())
1294 return true;
1295
1296 if (Sym.isComdat() && !Sym.isDefined())
1297 return false;
1298
1299 if (Sym.isTemporary())
1300 return false;
1301
1302 if (Sym.isSection())
1303 return false;
1304
1305 if (Sym.omitFromLinkingSection())
1306 return false;
1307
1308 return true;
1309}
1310
1311 static bool isSectionReferenced(MCAssembler &Asm, MCSectionWasm &Section) {
1312 StringRef SectionName = Section.getName();
1313
1314 for (const MCSymbol &S : Asm.symbols()) {
1315 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1316 if (WS.isData() && WS.isInSection()) {
1317 auto &RefSection = static_cast<MCSectionWasm &>(WS.getSection());
1318 if (RefSection.getName() == SectionName) {
1319 return true;
1320 }
1321 }
1322 }
1323
1324 return false;
1325}
1326
1327void WasmObjectWriter::prepareImports(
1328 SmallVectorImpl<wasm::WasmImport> &Imports, MCAssembler &Asm) {
1329 // For now, always emit the memory import, since loads and stores are not
1330 // valid without it. In the future, we could perhaps be more clever and omit
1331 // it if there are no loads or stores.
1332 wasm::WasmImport MemImport;
1333 MemImport.Module = "env";
1334 MemImport.Field = "__linear_memory";
1335 MemImport.Kind = wasm::WASM_EXTERNAL_MEMORY;
1336 MemImport.Memory.Flags = is64Bit() ? wasm::WASM_LIMITS_FLAG_IS_64
1337 : wasm::WASM_LIMITS_FLAG_NONE;
1338 Imports.push_back(MemImport);
1339
1340 // Populate SignatureIndices, and Imports and WasmIndices for undefined
1341 // symbols. This must be done before populating WasmIndices for defined
1342 // symbols.
1343 for (const MCSymbol &S : Asm.symbols()) {
1344 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1345
1346 // Register types for all functions, including those with private linkage
1347 // (because wasm always needs a type signature).
1348 if (WS.isFunction()) {
1349 auto *BS = static_cast<const MCSymbolWasm *>(Asm.getBaseSymbol(S));
1350 if (!BS)
1351 report_fatal_error(Twine(S.getName()) +
1352 ": absolute addressing not supported!");
1353 registerFunctionType(*BS);
1354 }
1355
1356 if (WS.isTag())
1357 registerTagType(WS);
1358
1359 if (WS.isTemporary())
1360 continue;
1361
1362 // If the symbol is not defined in this translation unit, import it.
1363 if (!WS.isDefined() && !WS.isComdat()) {
1364 if (WS.isFunction()) {
1365 wasm::WasmImport Import;
1366 Import.Module = WS.getImportModule();
1367 Import.Field = WS.getImportName();
1368 Import.Kind = wasm::WASM_EXTERNAL_FUNCTION;
1369 Import.SigIndex = getFunctionType(WS);
1370 Imports.push_back(Import);
1371 assert(WasmIndices.count(&WS) == 0);
1372 WasmIndices[&WS] = NumFunctionImports++;
1373 } else if (WS.isGlobal()) {
1374 if (WS.isWeak())
1375 report_fatal_error("undefined global symbol cannot be weak");
1376
1377 wasm::WasmImport Import;
1378 Import.Field = WS.getImportName();
1379 Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
1380 Import.Module = WS.getImportModule();
1381 Import.Global = WS.getGlobalType();
1382 Imports.push_back(Import);
1383 assert(WasmIndices.count(&WS) == 0);
1384 WasmIndices[&WS] = NumGlobalImports++;
1385 } else if (WS.isTag()) {
1386 if (WS.isWeak())
1387 report_fatal_error("undefined tag symbol cannot be weak");
1388
1389 wasm::WasmImport Import;
1390 Import.Module = WS.getImportModule();
1391 Import.Field = WS.getImportName();
1392 Import.Kind = wasm::WASM_EXTERNAL_TAG;
1393 Import.SigIndex = getTagType(WS);
1394 Imports.push_back(Import);
1395 assert(WasmIndices.count(&WS) == 0);
1396 WasmIndices[&WS] = NumTagImports++;
1397 } else if (WS.isTable()) {
1398 if (WS.isWeak())
1399 report_fatal_error("undefined table symbol cannot be weak");
1400
1401 wasm::WasmImport Import;
1402 Import.Module = WS.getImportModule();
1403 Import.Field = WS.getImportName();
1404 Import.Kind = wasm::WASM_EXTERNAL_TABLE;
1405 Import.Table = WS.getTableType();
1406 Imports.push_back(Import);
1407 assert(WasmIndices.count(&WS) == 0);
1408 WasmIndices[&WS] = NumTableImports++;
1409 }
1410 }
1411 }
1412
1413 // Add imports for GOT globals
1414 for (const MCSymbol &S : Asm.symbols()) {
1415 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1416 if (WS.isUsedInGOT()) {
1417 wasm::WasmImport Import;
1418 if (WS.isFunction())
1419 Import.Module = "GOT.func";
1420 else
1421 Import.Module = "GOT.mem";
1422 Import.Field = WS.getName();
1423 Import.Kind = wasm::WASM_EXTERNAL_GLOBAL;
1424 Import.Global = {wasm::WASM_TYPE_I32, true};
1425 Imports.push_back(Import);
1426 assert(GOTIndices.count(&WS) == 0);
1427 GOTIndices[&WS] = NumGlobalImports++;
1428 }
1429 }
1430}
1431
1432uint64_t WasmObjectWriter::writeObject() {
1433 support::endian::Writer MainWriter(*OS, llvm::endianness::little);
1434 W = &MainWriter;
1435 if (IsSplitDwarf) {
1436 uint64_t TotalSize = writeOneObject(*Asm, DwoMode::NonDwoOnly);
1437 assert(DwoOS);
1438 support::endian::Writer DwoWriter(*DwoOS, llvm::endianness::little);
1439 W = &DwoWriter;
1440 return TotalSize + writeOneObject(*Asm, DwoMode::DwoOnly);
1441 } else {
1442 return writeOneObject(*Asm, DwoMode::AllSections);
1443 }
1444}
1445
1446uint64_t WasmObjectWriter::writeOneObject(MCAssembler &Asm,
1447 DwoMode Mode) {
1448 uint64_t StartOffset = W->OS.tell();
1449 SectionCount = 0;
1450 CustomSections.clear();
1451
1452 LLVM_DEBUG(dbgs() << "WasmObjectWriter::writeObject\n");
1453
1454 // Collect information from the available symbols.
1455 SmallVector<WasmFunction, 4> Functions;
1456 SmallVector<uint32_t, 4> TableElems;
1457 SmallVector<wasm::WasmImport, 4> Imports;
1458 SmallVector<wasm::WasmExport, 4> Exports;
1459 SmallVector<uint32_t, 2> TagTypes;
1460 SmallVector<wasm::WasmGlobal, 1> Globals;
1461 SmallVector<wasm::WasmTable, 1> Tables;
1462 SmallVector<wasm::WasmSymbolInfo, 4> SymbolInfos;
1463 SmallVector<std::pair<uint16_t, uint32_t>, 2> InitFuncs;
1464 std::map<StringRef, std::vector<WasmComdatEntry>> Comdats;
1465 uint64_t DataSize = 0;
1466 if (Mode != DwoMode::DwoOnly)
1467 prepareImports(Imports, Asm);
1468
1469 // Populate DataSegments and CustomSections, which must be done before
1470 // populating DataLocations.
1471 for (MCSection &Sec : Asm) {
1472 auto &Section = static_cast<MCSectionWasm &>(Sec);
1473 StringRef SectionName = Section.getName();
1474
1475 if (Mode == DwoMode::NonDwoOnly && isDwoSection(Sec))
1476 continue;
1477 if (Mode == DwoMode::DwoOnly && !isDwoSection(Sec))
1478 continue;
1479
1480 LLVM_DEBUG(dbgs() << "Processing Section " << SectionName << " group "
1481 << Section.getGroup() << "\n";);
1482
1483 // .init_array sections are handled specially elsewhere, include them in
1484 // data segments if and only if referenced by a symbol.
1485 if (SectionName.starts_with(".init_array") &&
1486 !isSectionReferenced(Asm, Section))
1487 continue;
1488
1489 // Code is handled separately
1490 if (Section.isText())
1491 continue;
1492
1493 if (Section.isWasmData()) {
1494 uint32_t SegmentIndex = DataSegments.size();
1495 DataSize = alignTo(DataSize, Section.getAlign());
1496 DataSegments.emplace_back();
1497 WasmDataSegment &Segment = DataSegments.back();
1498 Segment.Name = SectionName;
1499 Segment.InitFlags = Section.getPassive()
1500 ? (uint32_t)wasm::WASM_DATA_SEGMENT_IS_PASSIVE
1501 : 0;
1502 Segment.Offset = DataSize;
1503 Segment.Section = &Section;
1504 addData(Segment.Data, Section);
1505 Segment.Alignment = Log2(Section.getAlign());
1506 Segment.LinkingFlags = Section.getSegmentFlags();
1507 DataSize += Segment.Data.size();
1508 Section.setSegmentIndex(SegmentIndex);
1509
1510 if (const MCSymbolWasm *C = Section.getGroup()) {
1511 Comdats[C->getName()].emplace_back(
1512 WasmComdatEntry{wasm::WASM_COMDAT_DATA, SegmentIndex});
1513 }
1514 } else {
1515 // Create custom sections
1516 assert(Section.isMetadata());
1517
1518 StringRef Name = SectionName;
1519
1520 // For user-defined custom sections, strip the prefix
1521 Name.consume_front(".custom_section.");
1522
1523 auto *Begin = static_cast<MCSymbolWasm *>(Sec.getBeginSymbol());
1524 if (Begin) {
1525 assert(WasmIndices.count(Begin) == 0);
1526 WasmIndices[Begin] = CustomSections.size();
1527 }
1528
1529 // Separate out the producers and target features sections
1530 if (Name == "producers") {
1531 ProducersSection = std::make_unique<WasmCustomSection>(Name, &Section);
1532 continue;
1533 }
1534 if (Name == "target_features") {
1535 TargetFeaturesSection =
1536 std::make_unique<WasmCustomSection>(Name, &Section);
1537 continue;
1538 }
1539
1540 // Custom sections can also belong to COMDAT groups. In this case the
1541 // decriptor's "index" field is the section index (in the final object
1542 // file), but that is not known until after layout, so it must be fixed up
1543 // later
1544 if (const MCSymbolWasm *C = Section.getGroup()) {
1545 Comdats[C->getName()].emplace_back(
1546 WasmComdatEntry{wasm::WASM_COMDAT_SECTION,
1547 static_cast<uint32_t>(CustomSections.size())});
1548 }
1549
1550 CustomSections.emplace_back(Name, &Section);
1551 }
1552 }
1553
1554 if (Mode != DwoMode::DwoOnly) {
1555 // Populate WasmIndices and DataLocations for defined symbols.
1556 for (const MCSymbol &S : Asm.symbols()) {
1557 // Ignore unnamed temporary symbols, which aren't ever exported, imported,
1558 // or used in relocations.
1559 if (S.isTemporary() && S.getName().empty())
1560 continue;
1561
1562 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1563 LLVM_DEBUG(
1564 dbgs() << "MCSymbol: "
1565 << toString(WS.getType().value_or(wasm::WASM_SYMBOL_TYPE_DATA))
1566 << " '" << S << "'"
1567 << " isDefined=" << S.isDefined() << " isExternal="
1568 << WS.isExternal() << " isTemporary=" << S.isTemporary()
1569 << " isWeak=" << WS.isWeak() << " isHidden=" << WS.isHidden()
1570 << " isVariable=" << WS.isVariable() << "\n");
1571
1572 if (WS.isVariable())
1573 continue;
1574 if (WS.isComdat() && !WS.isDefined())
1575 continue;
1576
1577 if (WS.isFunction()) {
1578 unsigned Index;
1579 if (WS.isDefined()) {
1580 if (WS.getOffset() != 0)
1581 report_fatal_error(
1582 "function sections must contain one function each");
1583
1584 // A definition. Write out the function body.
1585 Index = NumFunctionImports + Functions.size();
1586 WasmFunction Func;
1587 Func.SigIndex = getFunctionType(WS);
1588 Func.Section = &WS.getSection();
1589 assert(WasmIndices.count(&WS) == 0);
1590 WasmIndices[&WS] = Index;
1591 Functions.push_back(Func);
1592
1593 auto &Section = static_cast<MCSectionWasm &>(WS.getSection());
1594 if (const MCSymbolWasm *C = Section.getGroup()) {
1595 Comdats[C->getName()].emplace_back(
1596 WasmComdatEntry{wasm::WASM_COMDAT_FUNCTION, Index});
1597 }
1598
1599 if (WS.hasExportName()) {
1600 wasm::WasmExport Export;
1601 Export.Name = WS.getExportName();
1602 Export.Kind = wasm::WASM_EXTERNAL_FUNCTION;
1603 Export.Index = Index;
1604 Exports.push_back(Export);
1605 }
1606 } else {
1607 // An import; the index was assigned above.
1608 Index = WasmIndices.find(&WS)->second;
1609 }
1610
1611 LLVM_DEBUG(dbgs() << " -> function index: " << Index << "\n");
1612
1613 } else if (WS.isData()) {
1614 if (!isInSymtab(WS))
1615 continue;
1616
1617 if (!WS.isDefined()) {
1618 LLVM_DEBUG(dbgs() << " -> segment index: -1"
1619 << "\n");
1620 continue;
1621 }
1622
1623 if (!WS.getSize())
1624 report_fatal_error("data symbols must have a size set with .size: " +
1625 WS.getName());
1626
1627 int64_t Size = 0;
1628 if (!WS.getSize()->evaluateAsAbsolute(Size, Asm))
1629 report_fatal_error(".size expression must be evaluatable");
1630
1631 auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
1632 if (!DataSection.isWasmData())
1633 report_fatal_error("data symbols must live in a data section: " +
1634 WS.getName());
1635
1636 // For each data symbol, export it in the symtab as a reference to the
1637 // corresponding Wasm data segment.
1638 wasm::WasmDataReference Ref = wasm::WasmDataReference{
1639 DataSection.getSegmentIndex(), Asm.getSymbolOffset(WS),
1640 static_cast<uint64_t>(Size)};
1641 assert(DataLocations.count(&WS) == 0);
1642 DataLocations[&WS] = Ref;
1643 LLVM_DEBUG(dbgs() << " -> segment index: " << Ref.Segment << "\n");
1644
1645 } else if (WS.isGlobal()) {
1646 // A "true" Wasm global (currently just __stack_pointer)
1647 if (WS.isDefined()) {
1648 wasm::WasmGlobal Global;
1649 Global.Type = WS.getGlobalType();
1650 Global.Index = NumGlobalImports + Globals.size();
1651 Global.InitExpr.Extended = false;
1652 switch (Global.Type.Type) {
1653 case wasm::WASM_TYPE_I32:
1654 Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_I32_CONST;
1655 break;
1656 case wasm::WASM_TYPE_I64:
1657 Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_I64_CONST;
1658 break;
1659 case wasm::WASM_TYPE_F32:
1660 Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_F32_CONST;
1661 break;
1662 case wasm::WASM_TYPE_F64:
1663 Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_F64_CONST;
1664 break;
1665 case wasm::WASM_TYPE_EXTERNREF:
1666 Global.InitExpr.Inst.Opcode = wasm::WASM_OPCODE_REF_NULL;
1667 break;
1668 default:
1669 llvm_unreachable("unexpected type");
1670 }
1671 assert(WasmIndices.count(&WS) == 0);
1672 WasmIndices[&WS] = Global.Index;
1673 Globals.push_back(Global);
1674 } else {
1675 // An import; the index was assigned above
1676 LLVM_DEBUG(dbgs() << " -> global index: "
1677 << WasmIndices.find(&WS)->second << "\n");
1678 }
1679 } else if (WS.isTable()) {
1680 if (WS.isDefined()) {
1681 wasm::WasmTable Table;
1682 Table.Index = NumTableImports + Tables.size();
1683 Table.Type = WS.getTableType();
1684 assert(WasmIndices.count(&WS) == 0);
1685 WasmIndices[&WS] = Table.Index;
1686 Tables.push_back(Table);
1687 }
1688 LLVM_DEBUG(dbgs() << " -> table index: "
1689 << WasmIndices.find(&WS)->second << "\n");
1690 } else if (WS.isTag()) {
1691 // C++ exception symbol (__cpp_exception) or longjmp symbol
1692 // (__c_longjmp)
1693 unsigned Index;
1694 if (WS.isDefined()) {
1695 Index = NumTagImports + TagTypes.size();
1696 uint32_t SigIndex = getTagType(WS);
1697 assert(WasmIndices.count(&WS) == 0);
1698 WasmIndices[&WS] = Index;
1699 TagTypes.push_back(SigIndex);
1700 } else {
1701 // An import; the index was assigned above.
1702 assert(WasmIndices.count(&WS) > 0);
1703 }
1704 LLVM_DEBUG(dbgs() << " -> tag index: " << WasmIndices.find(&WS)->second
1705 << "\n");
1706
1707 } else {
1708 assert(WS.isSection());
1709 }
1710 }
1711
1712 // Populate WasmIndices and DataLocations for aliased symbols. We need to
1713 // process these in a separate pass because we need to have processed the
1714 // target of the alias before the alias itself and the symbols are not
1715 // necessarily ordered in this way.
1716 for (const MCSymbol &S : Asm.symbols()) {
1717 if (!S.isVariable())
1718 continue;
1719
1720 assert(S.isDefined());
1721
1722 const auto *BS = Asm.getBaseSymbol(S);
1723 if (!BS)
1724 report_fatal_error(Twine(S.getName()) +
1725 ": absolute addressing not supported!");
1726 const MCSymbolWasm *Base = static_cast<const MCSymbolWasm *>(BS);
1727
1728 // Find the target symbol of this weak alias and export that index
1729 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1730 LLVM_DEBUG(dbgs() << WS.getName() << ": weak alias of '" << *Base
1731 << "'\n");
1732
1733 if (Base->isFunction()) {
1734 assert(WasmIndices.count(Base) > 0);
1735 uint32_t WasmIndex = WasmIndices.find(Base)->second;
1736 assert(WasmIndices.count(&WS) == 0);
1737 WasmIndices[&WS] = WasmIndex;
1738 LLVM_DEBUG(dbgs() << " -> index:" << WasmIndex << "\n");
1739 } else if (Base->isData()) {
1740 auto &DataSection = static_cast<MCSectionWasm &>(WS.getSection());
1741 uint64_t Offset = Asm.getSymbolOffset(S);
1742 int64_t Size = 0;
1743 // For data symbol alias we use the size of the base symbol as the
1744 // size of the alias. When an offset from the base is involved this
1745 // can result in a offset + size goes past the end of the data section
1746 // which out object format doesn't support. So we must clamp it.
1747 if (!Base->getSize()->evaluateAsAbsolute(Size, Asm))
1748 report_fatal_error(".size expression must be evaluatable");
1749 const WasmDataSegment &Segment =
1750 DataSegments[DataSection.getSegmentIndex()];
1751 Size =
1752 std::min(static_cast<uint64_t>(Size), Segment.Data.size() - Offset);
1753 wasm::WasmDataReference Ref = wasm::WasmDataReference{
1754 DataSection.getSegmentIndex(),
1755 static_cast<uint32_t>(Asm.getSymbolOffset(S)),
1756 static_cast<uint32_t>(Size)};
1757 DataLocations[&WS] = Ref;
1758 LLVM_DEBUG(dbgs() << " -> index:" << Ref.Segment << "\n");
1759 } else {
1760 report_fatal_error("don't yet support global/tag aliases");
1761 }
1762 }
1763 }
1764
1765 // Finally, populate the symbol table itself, in its "natural" order.
1766 for (const MCSymbol &S : Asm.symbols()) {
1767 const auto &WS = static_cast<const MCSymbolWasm &>(S);
1768 if (!isInSymtab(WS)) {
1769 WS.setIndex(InvalidIndex);
1770 continue;
1771 }
1772 // In bitcode generated by split-LTO-unit mode in ThinLTO, these lines can
1773 // appear:
1774 // module asm ".lto_set_conditional symbolA,symbolA.[moduleId]"
1775 // ...
1776 // (Here [moduleId] will be replaced by a real module hash ID)
1777 //
1778 // Here the original symbol (symbolA here) has been renamed to the new name
1779 // created by attaching its module ID, so the original symbol does not
1780 // appear in the bitcode anymore, and thus not in DataLocations. We should
1781 // ignore them.
1782 if (WS.isData() && WS.isDefined() && !DataLocations.count(&WS))
1783 continue;
1784 LLVM_DEBUG(dbgs() << "adding to symtab: " << WS << "\n");
1785
1786 uint32_t Flags = 0;
1787 if (WS.isWeak())
1788 Flags |= wasm::WASM_SYMBOL_BINDING_WEAK;
1789 if (WS.isHidden())
1790 Flags |= wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
1791 if (!WS.isExternal() && WS.isDefined())
1792 Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
1793 if (WS.isUndefined())
1794 Flags |= wasm::WASM_SYMBOL_UNDEFINED;
1795 if (WS.isNoStrip()) {
1796 Flags |= wasm::WASM_SYMBOL_NO_STRIP;
1797 if (isEmscripten()) {
1798 Flags |= wasm::WASM_SYMBOL_EXPORTED;
1799 }
1800 }
1801 if (WS.hasImportName())
1802 Flags |= wasm::WASM_SYMBOL_EXPLICIT_NAME;
1803 if (WS.hasExportName())
1804 Flags |= wasm::WASM_SYMBOL_EXPORTED;
1805 if (WS.isTLS())
1806 Flags |= wasm::WASM_SYMBOL_TLS;
1807
1808 wasm::WasmSymbolInfo Info;
1809 Info.Name = WS.getName();
1810 Info.Kind = WS.getType().value_or(wasm::WASM_SYMBOL_TYPE_DATA);
1811 Info.Flags = Flags;
1812 if (!WS.isData()) {
1813 assert(WasmIndices.count(&WS) > 0);
1814 Info.ElementIndex = WasmIndices.find(&WS)->second;
1815 } else if (WS.isDefined()) {
1816 assert(DataLocations.count(&WS) > 0);
1817 Info.DataRef = DataLocations.find(&WS)->second;
1818 }
1819 WS.setIndex(SymbolInfos.size());
1820 SymbolInfos.emplace_back(Info);
1821 }
1822
1823 {
1824 auto HandleReloc = [&](const WasmRelocationEntry &Rel) {
1825 // Functions referenced by a relocation need to put in the table. This is
1826 // purely to make the object file's provisional values readable, and is
1827 // ignored by the linker, which re-calculates the relocations itself.
1828 if (Rel.Type != wasm::R_WASM_TABLE_INDEX_I32 &&
1829 Rel.Type != wasm::R_WASM_TABLE_INDEX_I64 &&
1830 Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB &&
1831 Rel.Type != wasm::R_WASM_TABLE_INDEX_SLEB64 &&
1832 Rel.Type != wasm::R_WASM_TABLE_INDEX_REL_SLEB &&
1833 Rel.Type != wasm::R_WASM_TABLE_INDEX_REL_SLEB64)
1834 return;
1835 assert(Rel.Symbol->isFunction());
1836 auto *Base =
1837 static_cast<const MCSymbolWasm *>(Asm.getBaseSymbol(*Rel.Symbol));
1838 uint32_t FunctionIndex = WasmIndices.find(Base)->second;
1839 uint32_t TableIndex = TableElems.size() + InitialTableOffset;
1840 if (TableIndices.try_emplace(Base, TableIndex).second) {
1841 LLVM_DEBUG(dbgs() << " -> adding " << Base->getName()
1842 << " to table: " << TableIndex << "\n");
1843 TableElems.push_back(FunctionIndex);
1844 registerFunctionType(*Base);
1845 }
1846 };
1847
1848 for (const WasmRelocationEntry &RelEntry : CodeRelocations)
1849 HandleReloc(RelEntry);
1850 for (const WasmRelocationEntry &RelEntry : DataRelocations)
1851 HandleReloc(RelEntry);
1852 }
1853
1854 // Translate .init_array section contents into start functions.
1855 for (const MCSection &S : Asm) {
1856 const auto &WS = static_cast<const MCSectionWasm &>(S);
1857 if (WS.getName().starts_with(".fini_array"))
1858 report_fatal_error(".fini_array sections are unsupported");
1859 if (!WS.getName().starts_with(".init_array"))
1860 continue;
1861 auto IT = WS.begin();
1862 if (IT == WS.end())
1863 continue;
1864 for (auto *Frag = &*IT; Frag; Frag = Frag->getNext()) {
1865 if (Frag->hasInstructions() || (Frag->getKind() != MCFragment::FT_Align &&
1866 Frag->getKind() != MCFragment::FT_Data))
1867 report_fatal_error("only data supported in .init_array section");
1868
1869 uint16_t Priority = UINT16_MAX;
1870 unsigned PrefixLength = strlen(".init_array");
1871 if (WS.getName().size() > PrefixLength) {
1872 if (WS.getName()[PrefixLength] != '.')
1873 report_fatal_error(
1874 ".init_array section priority should start with '.'");
1875 if (WS.getName().substr(PrefixLength + 1).getAsInteger(10, Priority))
1876 report_fatal_error("invalid .init_array section priority");
1877 }
1878 assert(llvm::all_of(Frag->getContents(), [](char C) { return !C; }));
1879 for (const MCFixup &Fixup : Frag->getFixups()) {
1880 assert(Fixup.getKind() ==
1881 MCFixup::getDataKindForSize(is64Bit() ? 8 : 4));
1882 const MCExpr *Expr = Fixup.getValue();
1883 auto *SymRef = dyn_cast<MCSymbolRefExpr>(Expr);
1884 if (!SymRef)
1885 report_fatal_error(
1886 "fixups in .init_array should be symbol references");
1887 auto &TargetSym =
1888 static_cast<const MCSymbolWasm &>(SymRef->getSymbol());
1889 if (TargetSym.getIndex() == InvalidIndex)
1890 report_fatal_error("symbols in .init_array should exist in symtab");
1891 if (!TargetSym.isFunction())
1892 report_fatal_error("symbols in .init_array should be for functions");
1893 InitFuncs.push_back(std::make_pair(Priority, TargetSym.getIndex()));
1894 }
1895 }
1896 }
1897
1898 // Write out the Wasm header.
1899 writeHeader(Asm);
1900
1901 uint32_t CodeSectionIndex, DataSectionIndex;
1902 if (Mode != DwoMode::DwoOnly) {
1903 writeTypeSection(Signatures);
1904 writeImportSection(Imports, DataSize, TableElems.size());
1905 writeFunctionSection(Functions);
1906 writeTableSection(Tables);
1907 // Skip the "memory" section; we import the memory instead.
1908 writeTagSection(TagTypes);
1909 writeGlobalSection(Globals);
1910 writeExportSection(Exports);
1911 const MCSymbol *IndirectFunctionTable =
1912 getContext().lookupSymbol("__indirect_function_table");
1913 writeElemSection(static_cast<const MCSymbolWasm *>(IndirectFunctionTable),
1914 TableElems);
1915 writeDataCountSection();
1916
1917 CodeSectionIndex = writeCodeSection(Asm, Functions);
1918 DataSectionIndex = writeDataSection(Asm);
1919 }
1920
1921 // The Sections in the COMDAT list have placeholder indices (their index among
1922 // custom sections, rather than among all sections). Fix them up here.
1923 for (auto &Group : Comdats) {
1924 for (auto &Entry : Group.second) {
1925 if (Entry.Kind == wasm::WASM_COMDAT_SECTION) {
1926 Entry.Index += SectionCount;
1927 }
1928 }
1929 }
1930 for (auto &CustomSection : CustomSections)
1931 writeCustomSection(CustomSection, Asm);
1932
1933 if (Mode != DwoMode::DwoOnly) {
1934 writeLinkingMetaDataSection(SymbolInfos, InitFuncs, Comdats);
1935
1936 writeRelocSection(CodeSectionIndex, "CODE", CodeRelocations);
1937 writeRelocSection(DataSectionIndex, "DATA", DataRelocations);
1938 }
1939 writeCustomRelocSections();
1940 if (ProducersSection)
1941 writeCustomSection(*ProducersSection, Asm);
1942 if (TargetFeaturesSection)
1943 writeCustomSection(*TargetFeaturesSection, Asm);
1944
1945 // TODO: Translate the .comment section to the output.
1946 return W->OS.tell() - StartOffset;
1947}
1948
1949std::unique_ptr<MCObjectWriter>
1950 llvm::createWasmObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
1951 raw_pwrite_stream &OS) {
1952 return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS);
1953}
1954
1955std::unique_ptr<MCObjectWriter>
1956 llvm::createWasmDwoObjectWriter(std::unique_ptr<MCWasmObjectTargetWriter> MOTW,
1958 raw_pwrite_stream &DwoOS) {
1959 return std::make_unique<WasmObjectWriter>(std::move(MOTW), OS, DwoOS);
1960}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::values(clEnumValN(DefaultIT, "arm-default-it", "Generate any type of IT block"), clEnumValN(RestrictedIT, "arm-restrict-it", "Disallow complex IT blocks")))
A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
Analysis containing CSE Info
Definition CSEInfo.cpp:27
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
Definition Compiler.h:638
F
#define F(x, y, z)
Definition MD5.cpp:55
T
#define T
PowerPC TLS Dynamic Call Fixup
static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))
This file contains some templates that are useful if you are working with the STL at all.
#define LLVM_DEBUG(...)
Definition Debug.h:114
static const FuncProtoTy Signatures[]
static const unsigned InvalidIndex
static bool isSectionReferenced(MCAssembler &Asm, MCSectionWasm &Section)
static void addData(SmallVectorImpl< char > &DataBytes, MCSectionWasm &DataSection)
static bool isInSymtab(const MCSymbolWasm &Sym)
static bool isDwoSection(const MCSection &Sec)
static bool is64Bit(const char *name)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition ArrayRef.h:143
bool empty() const
empty - Check if the array is empty.
Definition ArrayRef.h:138
LLVM_ABI MCSymbol * lookupSymbol(const Twine &Name) const
Get the symbol for Name, or null.
Definition MCContext.cpp:464
LLVM_ABI void reportError(SMLoc L, const Twine &Msg)
Definition MCContext.cpp:1122
Encode information on a single operation to perform on a byte sequence (e.g., an encoded instruction)...
Definition MCFixup.h:61
static MCFixupKind getDataKindForSize(unsigned Size)
Return the generic fixup kind for a value with the given size.
Definition MCFixup.h:110
Defines the object file and target independent interfaces used by the assembler backend to write nati...
virtual void reset()
lifetime management
This represents a section on wasm.
Definition MCSectionWasm.h:26
uint64_t getSectionOffset() const
Definition MCSectionWasm.h:70
Instances of this class represent a uniqued identifier for a section in the current translation unit.
Definition MCSection.h:521
Align getAlign() const
Definition MCSection.h:604
bool isText() const
Definition MCSection.h:591
StringRef getName() const
Definition MCSection.h:590
MCSymbol * getBeginSymbol()
Definition MCSection.h:593
bool isGlobal() const
Definition MCSymbolWasm.h:48
bool isSection() const
Definition MCSymbolWasm.h:50
bool omitFromLinkingSection() const
Definition MCSymbolWasm.h:88
bool isComdat() const
Definition MCSymbolWasm.h:82
bool isUsedInInitArray() const
Definition MCSymbolWasm.h:130
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
bool isDefined() const
isDefined - Check if this symbol is defined (i.e., it has an address).
Definition MCSymbol.h:233
StringRef getName() const
getName - Get the symbol name.
Definition MCSymbol.h:188
uint32_t getIndex() const
Get the (implementation defined) index.
Definition MCSymbol.h:280
MCSection & getSection() const
Get the section associated with a defined, non-absolute symbol.
Definition MCSymbol.h:251
bool isTemporary() const
isTemporary - Check if this is an assembler temporary symbol.
Definition MCSymbol.h:205
bool isUsedInReloc() const
Definition MCSymbol.h:199
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition SmallVector.h:574
reference emplace_back(ArgTypes &&... Args)
Definition SmallVector.h:944
iterator insert(iterator I, T &&Elt)
Definition SmallVector.h:812
void resize(size_type N)
Definition SmallVector.h:639
void push_back(const T &Elt)
Definition SmallVector.h:417
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1203
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
bool ends_with(StringRef Suffix) const
Check if this string ends with the given Suffix.
Definition StringRef.h:273
Target - Wrapper for Target specific information.
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
LLVM Value Representation.
Definition Value.h:75
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
uint64_t tell() const
tell - Return the current offset with the file.
Definition raw_ostream.h:148
raw_ostream & write(unsigned char C)
An abstract base class for streams implementations that also support a pwrite operation.
Definition raw_ostream.h:435
void pwrite(const char *Ptr, size_t Size, uint64_t Offset)
Definition raw_ostream.h:443
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
const char SectionName[]
Definition AMDGPUPTNote.h:24
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
@ Section
Legacy Tags.
@ Entry
Definition COFF.h:862
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
bool isRelocRelocation(MCFixupKind FixupKind)
Definition MCFixup.h:135
NodeAddr< FuncNode * > Func
Definition RDFGraph.h:393
Context & getContext() const
Definition BasicBlock.h:99
void write64le(void *P, uint64_t V)
Definition Endian.h:478
void write32le(void *P, uint32_t V)
Definition Endian.h:475
const unsigned WASM_SYMBOL_UNDEFINED
Definition Wasm.h:247
@ WASM_INIT_FUNCS
Definition Wasm.h:196
@ WASM_COMDAT_INFO
Definition Wasm.h:197
@ WASM_SEGMENT_INFO
Definition Wasm.h:195
@ WASM_SYMBOL_TABLE
Definition Wasm.h:198
const unsigned WASM_SYMBOL_NO_STRIP
Definition Wasm.h:250
ValType
Definition Wasm.h:268
@ WASM_TYPE_I64
Definition Wasm.h:57
@ WASM_TYPE_F64
Definition Wasm.h:59
@ WASM_TYPE_EXTERNREF
Definition Wasm.h:66
@ WASM_TYPE_FUNC
Definition Wasm.h:75
@ WASM_TYPE_I32
Definition Wasm.h:56
@ WASM_TYPE_F32
Definition Wasm.h:58
const char WasmMagic[]
Definition Wasm.h:27
const unsigned WASM_SYMBOL_TLS
Definition Wasm.h:251
const uint32_t WasmMetadataVersion
Definition Wasm.h:31
const unsigned WASM_SYMBOL_BINDING_WEAK
Definition Wasm.h:243
@ WASM_SEC_CODE
Definition Wasm.h:47
@ WASM_SEC_IMPORT
Definition Wasm.h:39
@ WASM_SEC_EXPORT
Definition Wasm.h:44
@ WASM_SEC_DATACOUNT
Definition Wasm.h:49
@ WASM_SEC_CUSTOM
Definition Wasm.h:37
@ WASM_SEC_FUNCTION
Definition Wasm.h:40
@ WASM_SEC_ELEM
Definition Wasm.h:46
@ WASM_SEC_TABLE
Definition Wasm.h:41
@ WASM_SEC_TYPE
Definition Wasm.h:38
@ WASM_SEC_TAG
Definition Wasm.h:50
@ WASM_SEC_GLOBAL
Definition Wasm.h:43
@ WASM_SEC_DATA
Definition Wasm.h:48
const unsigned WASM_SYMBOL_BINDING_LOCAL
Definition Wasm.h:244
@ WASM_LIMITS_FLAG_HAS_MAX
Definition Wasm.h:159
@ WASM_LIMITS_FLAG_IS_64
Definition Wasm.h:161
@ WASM_LIMITS_FLAG_NONE
Definition Wasm.h:158
@ WASM_DATA_SEGMENT_IS_PASSIVE
Definition Wasm.h:166
@ WASM_DATA_SEGMENT_HAS_MEMINDEX
Definition Wasm.h:167
@ WASM_SYMBOL_TYPE_GLOBAL
Definition Wasm.h:222
@ WASM_SYMBOL_TYPE_DATA
Definition Wasm.h:221
@ WASM_SYMBOL_TYPE_TAG
Definition Wasm.h:224
@ WASM_SYMBOL_TYPE_TABLE
Definition Wasm.h:225
@ WASM_SYMBOL_TYPE_SECTION
Definition Wasm.h:223
@ WASM_SYMBOL_TYPE_FUNCTION
Definition Wasm.h:220
const uint32_t WasmVersion
Definition Wasm.h:29
const unsigned WASM_SYMBOL_EXPORTED
Definition Wasm.h:248
@ WASM_COMDAT_SECTION
Definition Wasm.h:215
@ WASM_COMDAT_FUNCTION
Definition Wasm.h:213
@ WASM_COMDAT_DATA
Definition Wasm.h:212
@ WASM_ELEM_SEGMENT_HAS_TABLE_NUMBER
Definition Wasm.h:173
LLVM_ABI bool relocTypeHasAddend(uint32_t type)
Definition Wasm.cpp:66
@ WASM_OPCODE_F64_CONST
Definition Wasm.h:107
@ WASM_OPCODE_END
Definition Wasm.h:95
@ WASM_OPCODE_REF_NULL
Definition Wasm.h:114
@ WASM_OPCODE_F32_CONST
Definition Wasm.h:106
@ WASM_OPCODE_I64_CONST
Definition Wasm.h:105
@ WASM_OPCODE_I32_CONST
Definition Wasm.h:104
@ WASM_EXTERNAL_TABLE
Definition Wasm.h:87
@ WASM_EXTERNAL_FUNCTION
Definition Wasm.h:86
@ WASM_EXTERNAL_TAG
Definition Wasm.h:90
@ WASM_EXTERNAL_MEMORY
Definition Wasm.h:88
@ WASM_EXTERNAL_GLOBAL
Definition Wasm.h:89
const uint32_t WasmDefaultPageSize
Definition Wasm.h:34
const unsigned WASM_SYMBOL_EXPLICIT_NAME
Definition Wasm.h:249
const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN
Definition Wasm.h:246
const unsigned WASM_ELEM_SEGMENT_MASK_HAS_ELEM_DESC
Definition Wasm.h:176
LLVM_ABI llvm::StringRef relocTypetoString(uint32_t type)
Definition Wasm.cpp:29
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
void dump(const SparseBitVector< ElementSize > &LHS, raw_ostream &out)
@ Offset
Definition DWP.cpp:477
FunctionAddr VTableAddr Value
Definition InstrProf.h:137
void stable_sort(R &&Range)
Definition STLExtras.h:2058
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1725
Printable print(const GCNRegPressure &RP, const GCNSubtarget *ST=nullptr, unsigned DynamicVGPRBlockSize=0)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
@ Export
Export information to summary.
Definition IPO.h:57
@ Import
Import information from summary.
Definition IPO.h:56
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition STLExtras.h:2136
FunctionAddr VTableAddr uintptr_t uintptr_t DataSize
Definition InstrProf.h:267
std::unique_ptr< MCObjectWriter > createWasmObjectWriter(std::unique_ptr< MCWasmObjectTargetWriter > MOTW, raw_pwrite_stream &OS)
Construct a new Wasm writer instance.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition Debug.cpp:207
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:167
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition SmallVector.h:1129
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
Definition Alignment.h:186
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
@ Global
Append to llvm.global_dtors.
@ Ref
The access may reference the value stored in memory.
Definition ModRef.h:32
@ FirstLiteralRelocationKind
Definition MCFixup.h:29
FunctionAddr VTableAddr uintptr_t uintptr_t Data
Definition InstrProf.h:189
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition Alignment.h:144
raw_ostream & operator<<(raw_ostream &OS, const APFixedPoint &FX)
Definition APFixedPoint.h:312
ArrayRef(const T &OneElt) -> ArrayRef< T >
std::string toString(const APInt &I, unsigned Radix, bool Signed, bool formatAsCLiteral=false, bool UpperCase=true, bool InsertSeparators=false)
Definition StringExtras.h:344
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
Definition LEB128.h:24
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
Definition LEB128.h:79
unsigned Log2(Align A)
Returns the log2 of the alignment.
Definition Alignment.h:197
std::unique_ptr< MCObjectWriter > createWasmDwoObjectWriter(std::unique_ptr< MCWasmObjectTargetWriter > MOTW, raw_pwrite_stream &OS, raw_pwrite_stream &DwoOS)
Adapter to write values to a stream in a particular byte order.
Definition EndianStream.h:67
void write(ArrayRef< value_type > Val)
Definition EndianStream.h:71
WasmLimits Memory
Definition Wasm.h:387
StringRef Field
Definition Wasm.h:381
StringRef Module
Definition Wasm.h:380
uint8_t Flags
Definition Wasm.h:322
SmallVector< ValType, 1 > Returns
Definition Wasm.h:507
SmallVector< ValType, 4 > Params
Definition Wasm.h:508
WasmTableType Type
Definition Wasm.h:335
uint32_t Index
Definition Wasm.h:334
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /