1//===-- WebAssemblyAsmPrinter.cpp - WebAssembly LLVM assembly 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/// \file
10/// This file contains a printer that converts from our internal
11/// representation of machine-dependent LLVM code to the WebAssembly assembly
12/// language.
13///
14//===----------------------------------------------------------------------===//
15
16#include "WebAssemblyAsmPrinter.h"
17#include "MCTargetDesc/WebAssemblyMCAsmInfo.h"
18#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
19#include "MCTargetDesc/WebAssemblyTargetStreamer.h"
20#include "TargetInfo/WebAssemblyTargetInfo.h"
21#include "Utils/WebAssemblyTypeUtilities.h"
22#include "WebAssembly.h"
23#include "WebAssemblyMCInstLower.h"
24#include "WebAssemblyMachineFunctionInfo.h"
25#include "WebAssemblyRegisterInfo.h"
26#include "WebAssemblyRuntimeLibcallSignatures.h"
27#include "WebAssemblyTargetMachine.h"
28#include "WebAssemblyUtilities.h"
29#include "llvm/ADT/MapVector.h"
30#include "llvm/ADT/SmallSet.h"
31#include "llvm/ADT/StringExtras.h"
32#include "llvm/Analysis/ValueTracking.h"
33#include "llvm/BinaryFormat/Wasm.h"
34#include "llvm/CodeGen/Analysis.h"
35#include "llvm/CodeGen/AsmPrinter.h"
36#include "llvm/CodeGen/MachineConstantPool.h"
37#include "llvm/CodeGen/MachineInstr.h"
38#include "llvm/CodeGen/MachineModuleInfoImpls.h"
39#include "llvm/IR/DataLayout.h"
40#include "llvm/IR/DebugInfoMetadata.h"
41#include "llvm/IR/GlobalVariable.h"
42#include "llvm/IR/Metadata.h"
43#include "llvm/IR/Module.h"
44#include "llvm/MC/MCContext.h"
45#include "llvm/MC/MCSectionWasm.h"
46#include "llvm/MC/MCStreamer.h"
47#include "llvm/MC/MCSymbol.h"
48#include "llvm/MC/MCSymbolWasm.h"
49#include "llvm/MC/TargetRegistry.h"
50#include "llvm/Support/Compiler.h"
51#include "llvm/Support/Debug.h"
52#include "llvm/Support/raw_ostream.h"
53
54using namespace llvm;
55
56#define DEBUG_TYPE "asm-printer"
57
58extern cl::opt<bool> WasmKeepRegisters;
59
60//===----------------------------------------------------------------------===//
61// Helpers.
62//===----------------------------------------------------------------------===//
63
64MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const {
65 const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
66 const TargetRegisterClass *TRC = MRI->getRegClass(Reg: RegNo);
67 for (MVT T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64, MVT::v16i8, MVT::v8i16,
68 MVT::v4i32, MVT::v2i64, MVT::v4f32, MVT::v2f64, MVT::v8f16})
69 if (TRI->isTypeLegalForClass(RC: *TRC, T))
70 return T;
71 LLVM_DEBUG(errs() << "Unknown type for register number: " << RegNo);
72 llvm_unreachable("Unknown register type");
73 return MVT::Other;
74}
75
76std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
77 Register RegNo = MO.getReg();
78 assert(RegNo.isVirtual() &&
79 "Unlowered physical register encountered during assembly printing");
80 assert(!MFI->isVRegStackified(RegNo));
81 unsigned WAReg = MFI->getWAReg(VReg: RegNo);
82 assert(WAReg != WebAssembly::UnusedReg);
83 return '$' + utostr(X: WAReg);
84}
85
86WebAssemblyTargetStreamer *WebAssemblyAsmPrinter::getTargetStreamer() {
87 MCTargetStreamer *TS = OutStreamer->getTargetStreamer();
88 return static_cast<WebAssemblyTargetStreamer *>(TS);
89}
90
91// Emscripten exception handling helpers
92//
93// This converts invoke names generated by LowerEmscriptenEHSjLj to real names
94// that are expected by JavaScript glue code. The invoke names generated by
95// Emscripten JS glue code are based on their argument and return types; for
96// example, for a function that takes an i32 and returns nothing, it is
97// 'invoke_vi'. But the format of invoke generated by LowerEmscriptenEHSjLj pass
98// contains a mangled string generated from their IR types, for example,
99// "__invoke_void_%struct.mystruct*_int", because final wasm types are not
100// available in the IR pass. So we convert those names to the form that
101// Emscripten JS code expects.
102//
103// Refer to LowerEmscriptenEHSjLj pass for more details.
104
105// Returns true if the given function name is an invoke name generated by
106// LowerEmscriptenEHSjLj pass.
107static bool isEmscriptenInvokeName(StringRef Name) {
108 if (Name.front() == '"' && Name.back() == '"')
109 Name = Name.substr(Start: 1, N: Name.size() - 2);
110 return Name.starts_with(Prefix: "__invoke_");
111}
112
113// Returns a character that represents the given wasm value type in invoke
114// signatures.
115static char getInvokeSig(wasm::ValType VT) {
116 switch (VT) {
117 case wasm::ValType::I32:
118 return 'i';
119 case wasm::ValType::I64:
120 return 'j';
121 case wasm::ValType::F32:
122 return 'f';
123 case wasm::ValType::F64:
124 return 'd';
125 case wasm::ValType::V128:
126 return 'V';
127 case wasm::ValType::FUNCREF:
128 return 'F';
129 case wasm::ValType::EXTERNREF:
130 return 'X';
131 case wasm::ValType::EXNREF:
132 return 'E';
133 default:
134 llvm_unreachable("Unhandled wasm::ValType enum");
135 }
136}
137
138// Given the wasm signature, generate the invoke name in the format JS glue code
139// expects.
140static std::string getEmscriptenInvokeSymbolName(wasm::WasmSignature *Sig) {
141 assert(Sig->Returns.size() <= 1);
142 std::string Ret = "invoke_";
143 if (!Sig->Returns.empty())
144 for (auto VT : Sig->Returns)
145 Ret += getInvokeSig(VT);
146 else
147 Ret += 'v';
148 // Invokes' first argument is a pointer to the original function, so skip it
149 for (unsigned I = 1, E = Sig->Params.size(); I < E; I++)
150 Ret += getInvokeSig(VT: Sig->Params[I]);
151 return Ret;
152}
153
154//===----------------------------------------------------------------------===//
155// WebAssemblyAsmPrinter Implementation.
156//===----------------------------------------------------------------------===//
157
158MCSymbolWasm *WebAssemblyAsmPrinter::getMCSymbolForFunction(
159 const Function *F, wasm::WasmSignature *Sig, bool &InvokeDetected) {
160 MCSymbolWasm *WasmSym = nullptr;
161
162 const bool EnableEmEH =
163 WebAssembly::WasmEnableEmEH || WebAssembly::WasmEnableEmSjLj;
164 if (EnableEmEH && isEmscriptenInvokeName(Name: F->getName())) {
165 assert(Sig);
166 InvokeDetected = true;
167 if (Sig->Returns.size() > 1) {
168 std::string Msg =
169 "Emscripten EH/SjLj does not support multivalue returns: " +
170 std::string(F->getName()) + ": " +
171 WebAssembly::signatureToString(Sig);
172 report_fatal_error(reason: Twine(Msg));
173 }
174 WasmSym = static_cast<MCSymbolWasm *>(
175 GetExternalSymbolSymbol(Sym: getEmscriptenInvokeSymbolName(Sig)));
176 } else {
177 WasmSym = static_cast<MCSymbolWasm *>(getSymbol(GV: F));
178 }
179 return WasmSym;
180}
181
182void WebAssemblyAsmPrinter::emitGlobalVariable(const GlobalVariable *GV) {
183 if (GV->hasCommonLinkage()) {
184 OutContext.reportError(L: SMLoc(),
185 Msg: "common symbols are not yet implemented for Wasm: " +
186 getSymbol(GV)->getName());
187 return;
188 }
189
190 if (!WebAssembly::isWasmVarAddressSpace(AS: GV->getAddressSpace())) {
191 AsmPrinter::emitGlobalVariable(GV);
192 return;
193 }
194
195 assert(!GV->isThreadLocal());
196 auto *Sym = static_cast<MCSymbolWasm *>(getSymbol(GV));
197 if (!Sym->getType()) {
198 SmallVector<MVT, 1> VTs;
199 Type *GlobalVT = GV->getValueType();
200 // Function-specific subtargets are not needed here: WebAssembly
201 // coalesces features before isel, so use the TargetMachine's
202 // module-wide subtarget to compute legal value types.
203 auto &WasmTM = static_cast<const WebAssemblyTargetMachine &>(TM);
204 const WebAssemblySubtarget *ST = WasmTM.getSubtargetImpl();
205 const WebAssemblyTargetLowering &TLI = *ST->getTargetLowering();
206 computeLegalValueVTs(TLI, Ctx&: GV->getParent()->getContext(),
207 DL: GV->getDataLayout(), Ty: GlobalVT, ValueVTs&: VTs);
208
209 WebAssembly::wasmSymbolSetType(Sym, GlobalVT, VTs,
210 /*Mutable=*/!GV->isConstant());
211 }
212
213 emitVisibility(Sym, Visibility: GV->getVisibility(), IsDefinition: !GV->isDeclaration());
214 emitSymbolType(Sym);
215 if (GV->hasInitializer()) {
216 assert(getSymbolPreferLocal(*GV) == Sym);
217 emitLinkage(GV, GVSym: Sym);
218 OutStreamer->emitLabel(Symbol: Sym);
219 // TODO: Actually emit the initializer value. Otherwise the global has the
220 // default value for its type (0, ref.null, etc).
221 OutStreamer->addBlankLine();
222 }
223}
224
225MCSymbol *WebAssemblyAsmPrinter::getOrCreateWasmSymbol(StringRef Name) {
226 auto *WasmSym = static_cast<MCSymbolWasm *>(GetExternalSymbolSymbol(Sym: Name));
227 // May be called multiple times, so early out.
228 if (WasmSym->getType())
229 return WasmSym;
230
231 const WebAssemblySubtarget &Subtarget = getSubtarget();
232
233 // Except for certain known symbols, all symbols used by CodeGen are
234 // functions. It's OK to hardcode knowledge of specific symbols here; this
235 // method is precisely there for fetching the signatures of known
236 // Clang-provided symbols.
237 if (Name == "__stack_pointer" || Name == "__tls_base" ||
238 Name == "__memory_base" || Name == "__table_base" ||
239 Name == "__tls_size" || Name == "__tls_align") {
240 bool Mutable = Name == "__stack_pointer" || Name == "__tls_base";
241 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
242 WasmSym->setGlobalType(wasm::WasmGlobalType{
243 .Type: uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
244 : wasm::WASM_TYPE_I32),
245 .Mutable: Mutable});
246 return WasmSym;
247 }
248
249 if (Name.starts_with(Prefix: "GCC_except_table")) {
250 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
251 return WasmSym;
252 }
253
254 SmallVector<wasm::ValType, 4> Returns;
255 SmallVector<wasm::ValType, 4> Params;
256 if (Name == "__cpp_exception" || Name == "__c_longjmp") {
257 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
258 WasmSym->setExternal(true);
259
260 // Currently both C++ exceptions and C longjmps have a single pointer type
261 // param. For C++ exceptions it is a pointer to an exception object, and for
262 // C longjmps it is pointer to a struct that contains a setjmp buffer and a
263 // longjmp return value. We may consider using multiple value parameters for
264 // longjmps later when multivalue support is ready.
265 wasm::ValType AddrType =
266 Subtarget.hasAddr64() ? wasm::ValType::I64 : wasm::ValType::I32;
267 Params.push_back(Elt: AddrType);
268 } else if (Name == "__wasm_get_stack_pointer" ||
269 Name == "__wasm_get_tls_base") {
270 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
271 Returns.push_back(Elt: wasm::ValType::I32);
272 } else if (Name == "__wasm_set_stack_pointer" ||
273 Name == "__wasm_set_tls_base") {
274 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
275 Params.push_back(Elt: wasm::ValType::I32);
276 } else { // Function symbols
277 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
278 WebAssembly::getLibcallSignature(Subtarget, Name, Rets&: Returns, Params);
279 }
280 auto Signature = OutContext.createWasmSignature();
281 Signature->Returns = std::move(Returns);
282 Signature->Params = std::move(Params);
283 WasmSym->setSignature(Signature);
284
285 return WasmSym;
286}
287
288void WebAssemblyAsmPrinter::emitSymbolType(const MCSymbolWasm *Sym) {
289 std::optional<wasm::WasmSymbolType> WasmTy = Sym->getType();
290 if (!WasmTy)
291 return;
292
293 switch (*WasmTy) {
294 case wasm::WASM_SYMBOL_TYPE_GLOBAL:
295 getTargetStreamer()->emitGlobalType(Sym);
296 break;
297 case wasm::WASM_SYMBOL_TYPE_TAG:
298 getTargetStreamer()->emitTagType(Sym);
299 break;
300 case wasm::WASM_SYMBOL_TYPE_TABLE:
301 getTargetStreamer()->emitTableType(Sym);
302 break;
303 default:
304 break; // We only handle globals, tags and tables here
305 }
306}
307
308void WebAssemblyAsmPrinter::emitDecls(const Module &M) {
309 if (signaturesEmitted)
310 return;
311 signaturesEmitted = true;
312
313 // Normally symbols for globals get discovered as the MI gets lowered,
314 // but we need to know about them ahead of time. This will however,
315 // only find symbols that have been used. Unused symbols from globals will
316 // not be found here.
317 MachineModuleInfoWasm &MMIW = MMI->getObjFileInfo<MachineModuleInfoWasm>();
318 for (StringRef Name : MMIW.MachineSymbolsUsed) {
319 auto *WasmSym = static_cast<MCSymbolWasm *>(getOrCreateWasmSymbol(Name));
320 if (WasmSym->isFunction()) {
321 // TODO(wvo): is there any case where this overlaps with the call to
322 // emitFunctionType in the loop below?
323 getTargetStreamer()->emitFunctionType(Sym: WasmSym);
324 }
325 }
326
327 for (auto &It : OutContext.getSymbols()) {
328 // Emit .globaltype, .tagtype, or .tabletype declarations for extern
329 // declarations, i.e. those that have only been declared (but not defined)
330 // in the current module
331 auto Sym = static_cast<MCSymbolWasm *>(It.getValue().Symbol);
332 if (Sym && !Sym->isDefined())
333 emitSymbolType(Sym);
334 }
335
336 DenseSet<MCSymbol *> InvokeSymbols;
337 for (const auto &F : M) {
338 if (F.isIntrinsic())
339 continue;
340
341 // Emit function type info for all functions. This will emit duplicate
342 // information for defined functions (which already have function type
343 // info emitted alongside their definition), but this is necessary in
344 // order to enable the single-pass WebAssemblyAsmTypeCheck to succeed.
345 SmallVector<MVT, 4> Results;
346 SmallVector<MVT, 4> Params;
347 computeSignatureVTs(Ty: F.getFunctionType(), TargetFunc: &F, ContextFunc: F, TM, Params, Results);
348 // At this point these MCSymbols may or may not have been created already
349 // and thus also contain a signature, but we need to get the signature
350 // anyway here in case it is an invoke that has not yet been created. We
351 // will discard it later if it turns out not to be necessary.
352 auto Signature = signatureFromMVTs(Ctx&: OutContext, Results, Params);
353 bool InvokeDetected = false;
354 auto *Sym = getMCSymbolForFunction(F: &F, Sig: Signature, InvokeDetected);
355
356 // Multiple functions can be mapped to the same invoke symbol. For
357 // example, two IR functions '__invoke_void_i8*' and '__invoke_void_i32'
358 // are both mapped to '__invoke_vi'. We keep them in a set once we emit an
359 // Emscripten EH symbol so we don't emit the same symbol twice.
360 if (InvokeDetected && !InvokeSymbols.insert(V: Sym).second)
361 continue;
362
363 Sym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
364 if (!Sym->getSignature()) {
365 Sym->setSignature(Signature);
366 }
367
368 getTargetStreamer()->emitFunctionType(Sym);
369
370 if (F.hasFnAttribute(Kind: "wasm-import-module")) {
371 StringRef Name =
372 F.getFnAttribute(Kind: "wasm-import-module").getValueAsString();
373 Sym->setImportModule(OutContext.allocateString(s: Name));
374 getTargetStreamer()->emitImportModule(Sym, ImportModule: Name);
375 }
376 if (F.hasFnAttribute(Kind: "wasm-import-name")) {
377 // If this is a converted Emscripten EH/SjLj symbol, we shouldn't use
378 // the original function name but the converted symbol name.
379 StringRef Name =
380 InvokeDetected
381 ? Sym->getName()
382 : F.getFnAttribute(Kind: "wasm-import-name").getValueAsString();
383 Sym->setImportName(OutContext.allocateString(s: Name));
384 getTargetStreamer()->emitImportName(Sym, ImportName: Name);
385 }
386
387 if (F.hasFnAttribute(Kind: "wasm-export-name")) {
388 auto *Sym = static_cast<MCSymbolWasm *>(getSymbol(GV: &F));
389 StringRef Name = F.getFnAttribute(Kind: "wasm-export-name").getValueAsString();
390 Sym->setExportName(OutContext.allocateString(s: Name));
391 getTargetStreamer()->emitExportName(Sym, ExportName: Name);
392 }
393 }
394}
395
396void WebAssemblyAsmPrinter::emitEndOfAsmFile(Module &M) {
397 // This is required to emit external declarations (like .functypes) when
398 // no functions are defined in the compilation unit and therefore,
399 // emitDecls() is not called until now.
400 emitDecls(M);
401
402 // When a function's address is taken, a TABLE_INDEX relocation is emitted
403 // against the function symbol at the use site. However the relocation
404 // doesn't explicitly refer to the table. In the future we may want to
405 // define a new kind of reloc against both the function and the table, so
406 // that the linker can see that the function symbol keeps the table alive,
407 // but for now manually mark the table as live.
408 for (const auto &F : M) {
409 if (!F.isIntrinsic() && F.hasAddressTaken()) {
410 MCSymbolWasm *FunctionTable =
411 WebAssembly::getOrCreateFunctionTableSymbol(Ctx&: OutContext, Subtarget);
412 OutStreamer->emitSymbolAttribute(Symbol: FunctionTable, Attribute: MCSA_NoDeadStrip);
413 break;
414 }
415 }
416
417 for (const auto &G : M.globals()) {
418 if (!G.hasInitializer() && G.hasExternalLinkage() &&
419 !WebAssembly::isWasmVarAddressSpace(AS: G.getAddressSpace()) &&
420 G.getValueType()->isSized()) {
421 uint16_t Size = G.getGlobalSize(DL: M.getDataLayout());
422 OutStreamer->emitELFSize(Symbol: getSymbol(GV: &G),
423 Value: MCConstantExpr::create(Value: Size, Ctx&: OutContext));
424 }
425 }
426
427 if (const NamedMDNode *Named = M.getNamedMetadata(Name: "wasm.custom_sections")) {
428 for (const Metadata *MD : Named->operands()) {
429 const auto *Tuple = dyn_cast<MDTuple>(Val: MD);
430 if (!Tuple || Tuple->getNumOperands() != 2)
431 continue;
432 const MDString *Name = dyn_cast<MDString>(Val: Tuple->getOperand(I: 0));
433 const MDString *Contents = dyn_cast<MDString>(Val: Tuple->getOperand(I: 1));
434 if (!Name || !Contents)
435 continue;
436
437 OutStreamer->pushSection();
438 std::string SectionName = (".custom_section." + Name->getString()).str();
439 MCSectionWasm *MySection =
440 OutContext.getWasmSection(Section: SectionName, K: SectionKind::getMetadata());
441 OutStreamer->switchSection(Section: MySection);
442 OutStreamer->emitBytes(Data: Contents->getString());
443 OutStreamer->popSection();
444 }
445 }
446
447 EmitProducerInfo(M);
448 EmitTargetFeatures(M);
449 EmitFunctionAttributes(M);
450}
451
452void WebAssemblyAsmPrinter::EmitProducerInfo(Module &M) {
453 llvm::SmallVector<std::pair<std::string, std::string>, 4> Languages;
454 if (const NamedMDNode *Debug = M.getNamedMetadata(Name: "llvm.dbg.cu")) {
455 llvm::SmallSet<StringRef, 4> SeenLanguages;
456 for (size_t I = 0, E = Debug->getNumOperands(); I < E; ++I) {
457 const auto *CU = cast<DICompileUnit>(Val: Debug->getOperand(i: I));
458 StringRef Language =
459 dwarf::LanguageString(Language: CU->getSourceLanguage().getUnversionedName());
460
461 Language.consume_front(Prefix: "DW_LANG_");
462 if (SeenLanguages.insert(V: Language).second)
463 Languages.emplace_back(Args: Language.str(), Args: "");
464 }
465 }
466
467 llvm::SmallVector<std::pair<std::string, std::string>, 4> Tools;
468 if (const NamedMDNode *Ident = M.getNamedMetadata(Name: "llvm.ident")) {
469 llvm::SmallSet<StringRef, 4> SeenTools;
470 for (size_t I = 0, E = Ident->getNumOperands(); I < E; ++I) {
471 const auto *S = cast<MDString>(Val: Ident->getOperand(i: I)->getOperand(I: 0));
472 std::pair<StringRef, StringRef> Field = S->getString().split(Separator: "version");
473 StringRef Name = Field.first.trim();
474 StringRef Version = Field.second.trim();
475 if (SeenTools.insert(V: Name).second)
476 Tools.emplace_back(Args: Name.str(), Args: Version.str());
477 }
478 }
479
480 int FieldCount = int(!Languages.empty()) + int(!Tools.empty());
481 if (FieldCount != 0) {
482 MCSectionWasm *Producers = OutContext.getWasmSection(
483 Section: ".custom_section.producers", K: SectionKind::getMetadata());
484 OutStreamer->pushSection();
485 OutStreamer->switchSection(Section: Producers);
486 OutStreamer->emitULEB128IntValue(Value: FieldCount);
487 for (auto &Producers : {std::make_pair(x: "language", y: &Languages),
488 std::make_pair(x: "processed-by", y: &Tools)}) {
489 if (Producers.second->empty())
490 continue;
491 OutStreamer->emitULEB128IntValue(Value: strlen(s: Producers.first));
492 OutStreamer->emitBytes(Data: Producers.first);
493 OutStreamer->emitULEB128IntValue(Value: Producers.second->size());
494 for (auto &Producer : *Producers.second) {
495 OutStreamer->emitULEB128IntValue(Value: Producer.first.size());
496 OutStreamer->emitBytes(Data: Producer.first);
497 OutStreamer->emitULEB128IntValue(Value: Producer.second.size());
498 OutStreamer->emitBytes(Data: Producer.second);
499 }
500 }
501 OutStreamer->popSection();
502 }
503}
504
505void WebAssemblyAsmPrinter::EmitTargetFeatures(Module &M) {
506 struct FeatureEntry {
507 uint8_t Prefix;
508 std::string Name;
509 };
510
511 // Read target features and linkage policies from module metadata
512 SmallVector<FeatureEntry, 4> EmittedFeatures;
513 auto EmitFeature = [&](std::string Feature) {
514 std::string MDKey = (StringRef("wasm-feature-") + Feature).str();
515 Metadata *Policy = M.getModuleFlag(Key: MDKey);
516 if (Policy == nullptr)
517 return;
518
519 FeatureEntry Entry;
520 Entry.Prefix = 0;
521 Entry.Name = Feature;
522
523 if (auto *MD = cast<ConstantAsMetadata>(Val: Policy))
524 if (auto *I = cast<ConstantInt>(Val: MD->getValue()))
525 Entry.Prefix = I->getZExtValue();
526
527 // Silently ignore invalid metadata
528 if (Entry.Prefix != wasm::WASM_FEATURE_PREFIX_USED &&
529 Entry.Prefix != wasm::WASM_FEATURE_PREFIX_DISALLOWED)
530 return;
531
532 EmittedFeatures.push_back(Elt: Entry);
533 };
534
535 for (const SubtargetFeatureKV &KV : WebAssemblyFeatureKV) {
536 EmitFeature(KV.key());
537 }
538 // This pseudo-feature tells the linker whether shared memory would be safe
539 EmitFeature("shared-mem");
540
541 // This is an "architecture", not a "feature", but we emit it as such for
542 // the benefit of tools like Binaryen and consistency with other producers.
543 // FIXME: Subtarget is null here, so can't Subtarget->hasAddr64() ?
544 if (M.getDataLayout().getPointerSize() == 8) {
545 // Can't use EmitFeature since "wasm-feature-memory64" is not a module
546 // flag.
547 EmittedFeatures.push_back(Elt: {.Prefix: wasm::WASM_FEATURE_PREFIX_USED, .Name: "memory64"});
548 }
549
550 if (EmittedFeatures.size() == 0)
551 return;
552
553 // Emit features and linkage policies into the "target_features" section
554 MCSectionWasm *FeaturesSection = OutContext.getWasmSection(
555 Section: ".custom_section.target_features", K: SectionKind::getMetadata());
556 OutStreamer->pushSection();
557 OutStreamer->switchSection(Section: FeaturesSection);
558
559 OutStreamer->emitULEB128IntValue(Value: EmittedFeatures.size());
560 for (auto &F : EmittedFeatures) {
561 OutStreamer->emitIntValue(Value: F.Prefix, Size: 1);
562 OutStreamer->emitULEB128IntValue(Value: F.Name.size());
563 OutStreamer->emitBytes(Data: F.Name);
564 }
565
566 OutStreamer->popSection();
567}
568
569void WebAssemblyAsmPrinter::EmitFunctionAttributes(Module &M) {
570 auto V = M.getNamedGlobal(Name: "llvm.global.annotations");
571 if (!V)
572 return;
573
574 // Group all the custom attributes by name.
575 MapVector<StringRef, SmallVector<MCSymbol *, 4>> CustomSections;
576 const ConstantArray *CA = cast<ConstantArray>(Val: V->getOperand(i_nocapture: 0));
577 for (Value *Op : CA->operands()) {
578 auto *CS = cast<ConstantStruct>(Val: Op);
579 // The first field is a pointer to the annotated variable.
580 Value *AnnotatedVar = CS->getOperand(i_nocapture: 0)->stripPointerCasts();
581 // Only annotated functions are supported for now.
582 if (!isa<Function>(Val: AnnotatedVar))
583 continue;
584 auto *F = cast<Function>(Val: AnnotatedVar);
585
586 // The second field is a pointer to a global annotation string.
587 auto *GV = cast<GlobalVariable>(Val: CS->getOperand(i_nocapture: 1)->stripPointerCasts());
588 StringRef AnnotationString;
589 getConstantStringInfo(V: GV, Str&: AnnotationString);
590 auto *Sym = static_cast<MCSymbolWasm *>(getSymbol(GV: F));
591 CustomSections[AnnotationString].push_back(Elt: Sym);
592 }
593
594 // Emit a custom section for each unique attribute.
595 for (const auto &[Name, Symbols] : CustomSections) {
596 MCSectionWasm *CustomSection = OutContext.getWasmSection(
597 Section: ".custom_section.llvm.func_attr.annotate." + Name, K: SectionKind::getMetadata());
598 OutStreamer->pushSection();
599 OutStreamer->switchSection(Section: CustomSection);
600
601 for (auto &Sym : Symbols) {
602 OutStreamer->emitValue(
603 Value: MCSymbolRefExpr::create(Symbol: Sym, specifier: WebAssembly::S_FUNCINDEX, Ctx&: OutContext),
604 Size: 4);
605 }
606 OutStreamer->popSection();
607 }
608}
609
610void WebAssemblyAsmPrinter::emitConstantPool() {
611 emitDecls(M: *MMI->getModule());
612 assert(MF->getConstantPool()->getConstants().empty() &&
613 "WebAssembly disables constant pools");
614}
615
616void WebAssemblyAsmPrinter::emitJumpTableInfo() {
617 // Nothing to do; jump tables are incorporated into the instruction stream.
618}
619
620void WebAssemblyAsmPrinter::emitFunctionBodyStart() {
621 const Function &F = MF->getFunction();
622 SmallVector<MVT, 1> ResultVTs;
623 SmallVector<MVT, 4> ParamVTs;
624 computeSignatureVTs(Ty: F.getFunctionType(), TargetFunc: &F, ContextFunc: F, TM, Params&: ParamVTs, Results&: ResultVTs);
625
626 auto Signature = signatureFromMVTs(Ctx&: OutContext, Results: ResultVTs, Params: ParamVTs);
627 auto *WasmSym = static_cast<MCSymbolWasm *>(CurrentFnSym);
628 WasmSym->setSignature(Signature);
629 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
630
631 getTargetStreamer()->emitFunctionType(Sym: WasmSym);
632
633 // Emit the function index.
634 if (MDNode *Idx = F.getMetadata(Kind: "wasm.index")) {
635 assert(Idx->getNumOperands() == 1);
636
637 getTargetStreamer()->emitIndIdx(Value: AsmPrinter::lowerConstant(
638 CV: cast<ConstantAsMetadata>(Val: Idx->getOperand(I: 0))->getValue()));
639 }
640
641 SmallVector<wasm::ValType, 16> Locals;
642 valTypesFromMVTs(In: MFI->getLocals(), Out&: Locals);
643 getTargetStreamer()->emitLocal(Types: Locals);
644
645 AsmPrinter::emitFunctionBodyStart();
646}
647
648void WebAssemblyAsmPrinter::emitInstruction(const MachineInstr *MI) {
649 LLVM_DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
650 WebAssembly_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(),
651 Features: Subtarget->getFeatureBits());
652
653 switch (MI->getOpcode()) {
654 case WebAssembly::ARGUMENT_i32:
655 case WebAssembly::ARGUMENT_i32_S:
656 case WebAssembly::ARGUMENT_i64:
657 case WebAssembly::ARGUMENT_i64_S:
658 case WebAssembly::ARGUMENT_f32:
659 case WebAssembly::ARGUMENT_f32_S:
660 case WebAssembly::ARGUMENT_f64:
661 case WebAssembly::ARGUMENT_f64_S:
662 case WebAssembly::ARGUMENT_v16i8:
663 case WebAssembly::ARGUMENT_v16i8_S:
664 case WebAssembly::ARGUMENT_v8i16:
665 case WebAssembly::ARGUMENT_v8i16_S:
666 case WebAssembly::ARGUMENT_v4i32:
667 case WebAssembly::ARGUMENT_v4i32_S:
668 case WebAssembly::ARGUMENT_v2i64:
669 case WebAssembly::ARGUMENT_v2i64_S:
670 case WebAssembly::ARGUMENT_v4f32:
671 case WebAssembly::ARGUMENT_v4f32_S:
672 case WebAssembly::ARGUMENT_v2f64:
673 case WebAssembly::ARGUMENT_v2f64_S:
674 case WebAssembly::ARGUMENT_v8f16:
675 case WebAssembly::ARGUMENT_v8f16_S:
676 case WebAssembly::ARGUMENT_externref:
677 case WebAssembly::ARGUMENT_externref_S:
678 case WebAssembly::ARGUMENT_funcref:
679 case WebAssembly::ARGUMENT_funcref_S:
680 case WebAssembly::ARGUMENT_exnref:
681 case WebAssembly::ARGUMENT_exnref_S:
682 // These represent values which are live into the function entry, so there's
683 // no instruction to emit.
684 break;
685 case WebAssembly::FALLTHROUGH_RETURN: {
686 // These instructions represent the implicit return at the end of a
687 // function body.
688 if (isVerbose()) {
689 OutStreamer->AddComment(T: "fallthrough-return");
690 OutStreamer->addBlankLine();
691 }
692 break;
693 }
694 case WebAssembly::COMPILER_FENCE:
695 // This is a compiler barrier that prevents instruction reordering during
696 // backend compilation, and should not be emitted.
697 break;
698 case WebAssembly::CATCH:
699 case WebAssembly::CATCH_S:
700 case WebAssembly::CATCH_REF:
701 case WebAssembly::CATCH_REF_S:
702 case WebAssembly::CATCH_ALL:
703 case WebAssembly::CATCH_ALL_S:
704 case WebAssembly::CATCH_ALL_REF:
705 case WebAssembly::CATCH_ALL_REF_S:
706 // These are pseudo instructions to represent catch clauses in try_table
707 // instruction to simulate block return values.
708 break;
709 default: {
710 WebAssemblyMCInstLower MCInstLowering(OutContext, *this);
711 MCInst TmpInst;
712 MCInstLowering.lower(MI, OutMI&: TmpInst);
713 EmitToStreamer(S&: *OutStreamer, Inst: TmpInst);
714 break;
715 }
716 }
717}
718
719bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
720 unsigned OpNo,
721 const char *ExtraCode,
722 raw_ostream &OS) {
723 // First try the generic code, which knows about modifiers like 'c' and 'n'.
724 if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
725 return false;
726
727 if (!ExtraCode) {
728 const MachineOperand &MO = MI->getOperand(i: OpNo);
729 switch (MO.getType()) {
730 case MachineOperand::MO_Immediate:
731 OS << MO.getImm();
732 return false;
733 case MachineOperand::MO_Register:
734 // FIXME: only opcode that still contains registers, as required by
735 // MachineInstr::getDebugVariable().
736 assert(MI->getOpcode() == WebAssembly::INLINEASM);
737 OS << regToString(MO);
738 return false;
739 case MachineOperand::MO_GlobalAddress:
740 PrintSymbolOperand(MO, OS);
741 return false;
742 case MachineOperand::MO_ExternalSymbol:
743 GetExternalSymbolSymbol(Sym: MO.getSymbolName())->print(OS, MAI);
744 printOffset(Offset: MO.getOffset(), OS);
745 return false;
746 case MachineOperand::MO_MachineBasicBlock:
747 MO.getMBB()->getSymbol()->print(OS, MAI);
748 return false;
749 default:
750 break;
751 }
752 }
753
754 return true;
755}
756
757bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
758 unsigned OpNo,
759 const char *ExtraCode,
760 raw_ostream &OS) {
761 // The current approach to inline asm is that "r" constraints are expressed
762 // as local indices, rather than values on the operand stack. This simplifies
763 // using "r" as it eliminates the need to push and pop the values in a
764 // particular order, however it also makes it impossible to have an "m"
765 // constraint. So we don't support it.
766
767 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
768}
769
770char WebAssemblyAsmPrinter::ID = 0;
771
772INITIALIZE_PASS(WebAssemblyAsmPrinter, "webassembly-asm-printer",
773 "WebAssembly Assmebly Printer", false, false)
774
775// Force static initialization.
776extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
777LLVMInitializeWebAssemblyAsmPrinter() {
778 RegisterAsmPrinter<WebAssemblyAsmPrinter> X(getTheWebAssemblyTarget32());
779 RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(getTheWebAssemblyTarget64());
780}
781