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