LLVM  15.0.0git
WebAssemblyAsmPrinter.cpp
Go to the documentation of this file.
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"
22 #include "WebAssembly.h"
23 #include "WebAssemblyMCInstLower.h"
28 #include "llvm/ADT/SmallSet.h"
29 #include "llvm/ADT/StringExtras.h"
30 #include "llvm/BinaryFormat/Wasm.h"
31 #include "llvm/CodeGen/Analysis.h"
36 #include "llvm/IR/DataLayout.h"
38 #include "llvm/IR/GlobalVariable.h"
39 #include "llvm/IR/Metadata.h"
40 #include "llvm/MC/MCContext.h"
41 #include "llvm/MC/MCSectionWasm.h"
42 #include "llvm/MC/MCStreamer.h"
43 #include "llvm/MC/MCSymbol.h"
44 #include "llvm/MC/MCSymbolWasm.h"
45 #include "llvm/MC/TargetRegistry.h"
46 #include "llvm/Support/Debug.h"
48 
49 using namespace llvm;
50 
51 #define DEBUG_TYPE "asm-printer"
52 
54 
55 //===----------------------------------------------------------------------===//
56 // Helpers.
57 //===----------------------------------------------------------------------===//
58 
59 MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const {
60  const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
61  const TargetRegisterClass *TRC = MRI->getRegClass(RegNo);
64  if (TRI->isTypeLegalForClass(*TRC, T))
65  return T;
66  LLVM_DEBUG(errs() << "Unknown type for register number: " << RegNo);
67  llvm_unreachable("Unknown register type");
68  return MVT::Other;
69 }
70 
72  Register RegNo = MO.getReg();
74  "Unlowered physical register encountered during assembly printing");
75  assert(!MFI->isVRegStackified(RegNo));
76  unsigned WAReg = MFI->getWAReg(RegNo);
78  return '$' + utostr(WAReg);
79 }
80 
82  MCTargetStreamer *TS = OutStreamer->getTargetStreamer();
83  return static_cast<WebAssemblyTargetStreamer *>(TS);
84 }
85 
86 // Emscripten exception handling helpers
87 //
88 // This converts invoke names generated by LowerEmscriptenEHSjLj to real names
89 // that are expected by JavaScript glue code. The invoke names generated by
90 // Emscripten JS glue code are based on their argument and return types; for
91 // example, for a function that takes an i32 and returns nothing, it is
92 // 'invoke_vi'. But the format of invoke generated by LowerEmscriptenEHSjLj pass
93 // contains a mangled string generated from their IR types, for example,
94 // "__invoke_void_%struct.mystruct*_int", because final wasm types are not
95 // available in the IR pass. So we convert those names to the form that
96 // Emscripten JS code expects.
97 //
98 // Refer to LowerEmscriptenEHSjLj pass for more details.
99 
100 // Returns true if the given function name is an invoke name generated by
101 // LowerEmscriptenEHSjLj pass.
103  if (Name.front() == '"' && Name.back() == '"')
104  Name = Name.substr(1, Name.size() - 2);
105  return Name.startswith("__invoke_");
106 }
107 
108 // Returns a character that represents the given wasm value type in invoke
109 // signatures.
110 static char getInvokeSig(wasm::ValType VT) {
111  switch (VT) {
112  case wasm::ValType::I32:
113  return 'i';
114  case wasm::ValType::I64:
115  return 'j';
116  case wasm::ValType::F32:
117  return 'f';
118  case wasm::ValType::F64:
119  return 'd';
120  case wasm::ValType::V128:
121  return 'V';
123  return 'F';
125  return 'X';
126  }
127  llvm_unreachable("Unhandled wasm::ValType enum");
128 }
129 
130 // Given the wasm signature, generate the invoke name in the format JS glue code
131 // expects.
133  assert(Sig->Returns.size() <= 1);
134  std::string Ret = "invoke_";
135  if (!Sig->Returns.empty())
136  for (auto VT : Sig->Returns)
137  Ret += getInvokeSig(VT);
138  else
139  Ret += 'v';
140  // Invokes' first argument is a pointer to the original function, so skip it
141  for (unsigned I = 1, E = Sig->Params.size(); I < E; I++)
142  Ret += getInvokeSig(Sig->Params[I]);
143  return Ret;
144 }
145 
146 //===----------------------------------------------------------------------===//
147 // WebAssemblyAsmPrinter Implementation.
148 //===----------------------------------------------------------------------===//
149 
151  const Function *F, bool EnableEmEH, wasm::WasmSignature *Sig,
152  bool &InvokeDetected) {
153  MCSymbolWasm *WasmSym = nullptr;
154  if (EnableEmEH && isEmscriptenInvokeName(F->getName())) {
155  assert(Sig);
156  InvokeDetected = true;
157  if (Sig->Returns.size() > 1) {
158  std::string Msg =
159  "Emscripten EH/SjLj does not support multivalue returns: " +
160  std::string(F->getName()) + ": " +
163  }
164  WasmSym = cast<MCSymbolWasm>(
166  } else {
167  WasmSym = cast<MCSymbolWasm>(getSymbol(F));
168  }
169  return WasmSym;
170 }
171 
175  return;
176  }
177 
178  assert(!GV->isThreadLocal());
179 
180  MCSymbolWasm *Sym = cast<MCSymbolWasm>(getSymbol(GV));
181 
182  if (!Sym->getType()) {
184  Type *GlobalVT = GV->getValueType();
185  if (Subtarget) {
186  // Subtarget is only set when a function is defined, because
187  // each function can declare a different subtarget. For example,
188  // on ARM a compilation unit might have a function on ARM and
189  // another on Thumb. Therefore only if Subtarget is non-null we
190  // can actually calculate the legal VTs.
191  const WebAssemblyTargetLowering &TLI = *Subtarget->getTargetLowering();
193  GV->getParent()->getDataLayout(), GlobalVT, VTs);
194  }
195  WebAssembly::wasmSymbolSetType(Sym, GlobalVT, VTs);
196  }
197 
198  emitVisibility(Sym, GV->getVisibility(), !GV->isDeclaration());
199  emitSymbolType(Sym);
200  if (GV->hasInitializer()) {
201  assert(getSymbolPreferLocal(*GV) == Sym);
202  emitLinkage(GV, Sym);
203  OutStreamer->emitLabel(Sym);
204  // TODO: Actually emit the initializer value. Otherwise the global has the
205  // default value for its type (0, ref.null, etc).
206  OutStreamer->AddBlankLine();
207  }
208 }
209 
211  auto *WasmSym = cast<MCSymbolWasm>(GetExternalSymbolSymbol(Name));
212 
213  // May be called multiple times, so early out.
214  if (WasmSym->getType().hasValue())
215  return WasmSym;
216 
217  const WebAssemblySubtarget &Subtarget = getSubtarget();
218 
219  // Except for certain known symbols, all symbols used by CodeGen are
220  // functions. It's OK to hardcode knowledge of specific symbols here; this
221  // method is precisely there for fetching the signatures of known
222  // Clang-provided symbols.
223  if (Name == "__stack_pointer" || Name == "__tls_base" ||
224  Name == "__memory_base" || Name == "__table_base" ||
225  Name == "__tls_size" || Name == "__tls_align") {
226  bool Mutable =
227  Name == "__stack_pointer" || Name == "__tls_base";
228  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
229  WasmSym->setGlobalType(wasm::WasmGlobalType{
230  uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
232  Mutable});
233  return WasmSym;
234  }
235 
236  if (Name.startswith("GCC_except_table")) {
237  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_DATA);
238  return WasmSym;
239  }
240 
243  if (Name == "__cpp_exception" || Name == "__c_longjmp") {
244  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
245  // In static linking we define tag symbols in WasmException::endModule().
246  // But we may have multiple objects to be linked together, each of which
247  // defines the tag symbols. To resolve them, we declare them as weak. In
248  // dynamic linking we make tag symbols undefined in the backend, define it
249  // in JS, and feed them to each importing module.
250  if (!isPositionIndependent())
251  WasmSym->setWeak(true);
252  WasmSym->setExternal(true);
253 
254  // Currently both C++ exceptions and C longjmps have a single pointer type
255  // param. For C++ exceptions it is a pointer to an exception object, and for
256  // C longjmps it is pointer to a struct that contains a setjmp buffer and a
257  // longjmp return value. We may consider using multiple value parameters for
258  // longjmps later when multivalue support is ready.
259  wasm::ValType AddrType =
261  Params.push_back(AddrType);
262  } else { // Function symbols
263  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
264  getLibcallSignature(Subtarget, Name, Returns, Params);
265  }
266  auto Signature = std::make_unique<wasm::WasmSignature>(std::move(Returns),
267  std::move(Params));
268  WasmSym->setSignature(Signature.get());
269  addSignature(std::move(Signature));
270 
271  return WasmSym;
272 }
273 
275  Optional<wasm::WasmSymbolType> WasmTy = Sym->getType();
276  if (!WasmTy)
277  return;
278 
279  switch (WasmTy.getValue()) {
282  break;
285  break;
288  break;
289  default:
290  break; // We only handle globals, tags and tables here
291  }
292 }
293 
295  if (signaturesEmitted)
296  return;
297  signaturesEmitted = true;
298 
299  // Normally symbols for globals get discovered as the MI gets lowered,
300  // but we need to know about them ahead of time. This will however,
301  // only find symbols that have been used. Unused symbols from globals will
302  // not be found here.
304  for (const auto &Name : MMIW.MachineSymbolsUsed) {
305  auto *WasmSym = cast<MCSymbolWasm>(getOrCreateWasmSymbol(Name.getKey()));
306  if (WasmSym->isFunction()) {
307  // TODO(wvo): is there any case where this overlaps with the call to
308  // emitFunctionType in the loop below?
310  }
311  }
312 
313  for (auto &It : OutContext.getSymbols()) {
314  // Emit .globaltype, .tagtype, or .tabletype declarations for extern
315  // declarations, i.e. those that have only been declared (but not defined)
316  // in the current module
317  auto Sym = cast<MCSymbolWasm>(It.getValue());
318  if (!Sym->isDefined())
319  emitSymbolType(Sym);
320  }
321 
322  DenseSet<MCSymbol *> InvokeSymbols;
323  for (const auto &F : M) {
324  if (F.isIntrinsic())
325  continue;
326 
327  // Emit function type info for all functions. This will emit duplicate
328  // information for defined functions (which already have function type
329  // info emitted alongside their definition), but this is necessary in
330  // order to enable the single-pass WebAssemblyAsmTypeCheck to succeed.
332  SmallVector<MVT, 4> Params;
333  computeSignatureVTs(F.getFunctionType(), &F, F, TM, Params, Results);
334  // At this point these MCSymbols may or may not have been created already
335  // and thus also contain a signature, but we need to get the signature
336  // anyway here in case it is an invoke that has not yet been created. We
337  // will discard it later if it turns out not to be necessary.
338  auto Signature = signatureFromMVTs(Results, Params);
339  bool InvokeDetected = false;
340  auto *Sym = getMCSymbolForFunction(
342  Signature.get(), InvokeDetected);
343 
344  // Multiple functions can be mapped to the same invoke symbol. For
345  // example, two IR functions '__invoke_void_i8*' and '__invoke_void_i32'
346  // are both mapped to '__invoke_vi'. We keep them in a set once we emit an
347  // Emscripten EH symbol so we don't emit the same symbol twice.
348  if (InvokeDetected && !InvokeSymbols.insert(Sym).second)
349  continue;
350 
351  Sym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
352  if (!Sym->getSignature()) {
353  Sym->setSignature(Signature.get());
354  addSignature(std::move(Signature));
355  } else {
356  // This symbol has already been created and had a signature. Discard it.
357  Signature.reset();
358  }
359 
361 
362  if (F.hasFnAttribute("wasm-import-module")) {
363  StringRef Name =
364  F.getFnAttribute("wasm-import-module").getValueAsString();
365  Sym->setImportModule(storeName(Name));
367  }
368  if (F.hasFnAttribute("wasm-import-name")) {
369  // If this is a converted Emscripten EH/SjLj symbol, we shouldn't use
370  // the original function name but the converted symbol name.
371  StringRef Name =
372  InvokeDetected
373  ? Sym->getName()
374  : F.getFnAttribute("wasm-import-name").getValueAsString();
375  Sym->setImportName(storeName(Name));
377  }
378 
379  if (F.hasFnAttribute("wasm-export-name")) {
380  auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
381  StringRef Name = F.getFnAttribute("wasm-export-name").getValueAsString();
382  Sym->setExportName(storeName(Name));
384  }
385  }
386 }
387 
389  // This is required to emit external declarations (like .functypes) when
390  // no functions are defined in the compilation unit and therefore,
391  // emitDecls() is not called until now.
392  emitDecls(M);
393 
394  // When a function's address is taken, a TABLE_INDEX relocation is emitted
395  // against the function symbol at the use site. However the relocation
396  // doesn't explicitly refer to the table. In the future we may want to
397  // define a new kind of reloc against both the function and the table, so
398  // that the linker can see that the function symbol keeps the table alive,
399  // but for now manually mark the table as live.
400  for (const auto &F : M) {
401  if (!F.isIntrinsic() && F.hasAddressTaken()) {
402  MCSymbolWasm *FunctionTable =
404  OutStreamer->emitSymbolAttribute(FunctionTable, MCSA_NoDeadStrip);
405  break;
406  }
407  }
408 
409  for (const auto &G : M.globals()) {
410  if (!G.hasInitializer() && G.hasExternalLinkage() &&
411  !WebAssembly::isWasmVarAddressSpace(G.getAddressSpace()) &&
412  G.getValueType()->isSized()) {
413  uint16_t Size = M.getDataLayout().getTypeAllocSize(G.getValueType());
414  OutStreamer->emitELFSize(getSymbol(&G),
416  }
417  }
418 
419  if (const NamedMDNode *Named = M.getNamedMetadata("wasm.custom_sections")) {
420  for (const Metadata *MD : Named->operands()) {
421  const auto *Tuple = dyn_cast<MDTuple>(MD);
422  if (!Tuple || Tuple->getNumOperands() != 2)
423  continue;
424  const MDString *Name = dyn_cast<MDString>(Tuple->getOperand(0));
425  const MDString *Contents = dyn_cast<MDString>(Tuple->getOperand(1));
426  if (!Name || !Contents)
427  continue;
428 
429  OutStreamer->PushSection();
430  std::string SectionName = (".custom_section." + Name->getString()).str();
431  MCSectionWasm *MySection =
433  OutStreamer->SwitchSection(MySection);
434  OutStreamer->emitBytes(Contents->getString());
435  OutStreamer->PopSection();
436  }
437  }
438 
441 }
442 
445  if (const NamedMDNode *Debug = M.getNamedMetadata("llvm.dbg.cu")) {
446  llvm::SmallSet<StringRef, 4> SeenLanguages;
447  for (size_t I = 0, E = Debug->getNumOperands(); I < E; ++I) {
448  const auto *CU = cast<DICompileUnit>(Debug->getOperand(I));
449  StringRef Language = dwarf::LanguageString(CU->getSourceLanguage());
450  Language.consume_front("DW_LANG_");
451  if (SeenLanguages.insert(Language).second)
452  Languages.emplace_back(Language.str(), "");
453  }
454  }
455 
457  if (const NamedMDNode *Ident = M.getNamedMetadata("llvm.ident")) {
459  for (size_t I = 0, E = Ident->getNumOperands(); I < E; ++I) {
460  const auto *S = cast<MDString>(Ident->getOperand(I)->getOperand(0));
461  std::pair<StringRef, StringRef> Field = S->getString().split("version");
462  StringRef Name = Field.first.trim();
463  StringRef Version = Field.second.trim();
464  if (SeenTools.insert(Name).second)
465  Tools.emplace_back(Name.str(), Version.str());
466  }
467  }
468 
469  int FieldCount = int(!Languages.empty()) + int(!Tools.empty());
470  if (FieldCount != 0) {
472  ".custom_section.producers", SectionKind::getMetadata());
473  OutStreamer->PushSection();
474  OutStreamer->SwitchSection(Producers);
475  OutStreamer->emitULEB128IntValue(FieldCount);
476  for (auto &Producers : {std::make_pair("language", &Languages),
477  std::make_pair("processed-by", &Tools)}) {
478  if (Producers.second->empty())
479  continue;
480  OutStreamer->emitULEB128IntValue(strlen(Producers.first));
481  OutStreamer->emitBytes(Producers.first);
482  OutStreamer->emitULEB128IntValue(Producers.second->size());
483  for (auto &Producer : *Producers.second) {
484  OutStreamer->emitULEB128IntValue(Producer.first.size());
485  OutStreamer->emitBytes(Producer.first);
486  OutStreamer->emitULEB128IntValue(Producer.second.size());
487  OutStreamer->emitBytes(Producer.second);
488  }
489  }
490  OutStreamer->PopSection();
491  }
492 }
493 
495  struct FeatureEntry {
496  uint8_t Prefix;
497  std::string Name;
498  };
499 
500  // Read target features and linkage policies from module metadata
501  SmallVector<FeatureEntry, 4> EmittedFeatures;
502  auto EmitFeature = [&](std::string Feature) {
503  std::string MDKey = (StringRef("wasm-feature-") + Feature).str();
504  Metadata *Policy = M.getModuleFlag(MDKey);
505  if (Policy == nullptr)
506  return;
507 
508  FeatureEntry Entry;
509  Entry.Prefix = 0;
510  Entry.Name = Feature;
511 
512  if (auto *MD = cast<ConstantAsMetadata>(Policy))
513  if (auto *I = cast<ConstantInt>(MD->getValue()))
514  Entry.Prefix = I->getZExtValue();
515 
516  // Silently ignore invalid metadata
517  if (Entry.Prefix != wasm::WASM_FEATURE_PREFIX_USED &&
518  Entry.Prefix != wasm::WASM_FEATURE_PREFIX_REQUIRED &&
519  Entry.Prefix != wasm::WASM_FEATURE_PREFIX_DISALLOWED)
520  return;
521 
522  EmittedFeatures.push_back(Entry);
523  };
524 
525  for (const SubtargetFeatureKV &KV : WebAssemblyFeatureKV) {
526  EmitFeature(KV.Key);
527  }
528  // This pseudo-feature tells the linker whether shared memory would be safe
529  EmitFeature("shared-mem");
530 
531  // This is an "architecture", not a "feature", but we emit it as such for
532  // the benefit of tools like Binaryen and consistency with other producers.
533  // FIXME: Subtarget is null here, so can't Subtarget->hasAddr64() ?
534  if (M.getDataLayout().getPointerSize() == 8) {
535  // Can't use EmitFeature since "wasm-feature-memory64" is not a module
536  // flag.
537  EmittedFeatures.push_back({wasm::WASM_FEATURE_PREFIX_USED, "memory64"});
538  }
539 
540  if (EmittedFeatures.size() == 0)
541  return;
542 
543  // Emit features and linkage policies into the "target_features" section
544  MCSectionWasm *FeaturesSection = OutContext.getWasmSection(
545  ".custom_section.target_features", SectionKind::getMetadata());
546  OutStreamer->PushSection();
547  OutStreamer->SwitchSection(FeaturesSection);
548 
549  OutStreamer->emitULEB128IntValue(EmittedFeatures.size());
550  for (auto &F : EmittedFeatures) {
551  OutStreamer->emitIntValue(F.Prefix, 1);
552  OutStreamer->emitULEB128IntValue(F.Name.size());
553  OutStreamer->emitBytes(F.Name);
554  }
555 
556  OutStreamer->PopSection();
557 }
558 
560  emitDecls(*MMI->getModule());
561  assert(MF->getConstantPool()->getConstants().empty() &&
562  "WebAssembly disables constant pools");
563 }
564 
566  // Nothing to do; jump tables are incorporated into the instruction stream.
567 }
568 
570  const Function &F = MF->getFunction();
571  SmallVector<MVT, 1> ResultVTs;
572  SmallVector<MVT, 4> ParamVTs;
573  computeSignatureVTs(F.getFunctionType(), &F, F, TM, ParamVTs, ResultVTs);
574 
575  auto Signature = signatureFromMVTs(ResultVTs, ParamVTs);
576  auto *WasmSym = cast<MCSymbolWasm>(CurrentFnSym);
577  WasmSym->setSignature(Signature.get());
578  addSignature(std::move(Signature));
579  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
580 
582 
583  // Emit the function index.
584  if (MDNode *Idx = F.getMetadata("wasm.index")) {
585  assert(Idx->getNumOperands() == 1);
586 
588  cast<ConstantAsMetadata>(Idx->getOperand(0))->getValue()));
589  }
590 
592  valTypesFromMVTs(MFI->getLocals(), Locals);
593  getTargetStreamer()->emitLocal(Locals);
594 
596 }
597 
599  LLVM_DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
600 
601  switch (MI->getOpcode()) {
602  case WebAssembly::ARGUMENT_i32:
603  case WebAssembly::ARGUMENT_i32_S:
604  case WebAssembly::ARGUMENT_i64:
605  case WebAssembly::ARGUMENT_i64_S:
606  case WebAssembly::ARGUMENT_f32:
607  case WebAssembly::ARGUMENT_f32_S:
608  case WebAssembly::ARGUMENT_f64:
609  case WebAssembly::ARGUMENT_f64_S:
610  case WebAssembly::ARGUMENT_v16i8:
611  case WebAssembly::ARGUMENT_v16i8_S:
612  case WebAssembly::ARGUMENT_v8i16:
613  case WebAssembly::ARGUMENT_v8i16_S:
614  case WebAssembly::ARGUMENT_v4i32:
615  case WebAssembly::ARGUMENT_v4i32_S:
616  case WebAssembly::ARGUMENT_v2i64:
617  case WebAssembly::ARGUMENT_v2i64_S:
618  case WebAssembly::ARGUMENT_v4f32:
619  case WebAssembly::ARGUMENT_v4f32_S:
620  case WebAssembly::ARGUMENT_v2f64:
621  case WebAssembly::ARGUMENT_v2f64_S:
622  // These represent values which are live into the function entry, so there's
623  // no instruction to emit.
624  break;
625  case WebAssembly::FALLTHROUGH_RETURN: {
626  // These instructions represent the implicit return at the end of a
627  // function body.
628  if (isVerbose()) {
629  OutStreamer->AddComment("fallthrough-return");
630  OutStreamer->AddBlankLine();
631  }
632  break;
633  }
634  case WebAssembly::COMPILER_FENCE:
635  // This is a compiler barrier that prevents instruction reordering during
636  // backend compilation, and should not be emitted.
637  break;
638  default: {
639  WebAssemblyMCInstLower MCInstLowering(OutContext, *this);
640  MCInst TmpInst;
641  MCInstLowering.lower(MI, TmpInst);
642  EmitToStreamer(*OutStreamer, TmpInst);
643  break;
644  }
645  }
646 }
647 
649  unsigned OpNo,
650  const char *ExtraCode,
651  raw_ostream &OS) {
652  // First try the generic code, which knows about modifiers like 'c' and 'n'.
653  if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
654  return false;
655 
656  if (!ExtraCode) {
657  const MachineOperand &MO = MI->getOperand(OpNo);
658  switch (MO.getType()) {
660  OS << MO.getImm();
661  return false;
663  // FIXME: only opcode that still contains registers, as required by
664  // MachineInstr::getDebugVariable().
665  assert(MI->getOpcode() == WebAssembly::INLINEASM);
666  OS << regToString(MO);
667  return false;
669  PrintSymbolOperand(MO, OS);
670  return false;
673  printOffset(MO.getOffset(), OS);
674  return false;
676  MO.getMBB()->getSymbol()->print(OS, MAI);
677  return false;
678  default:
679  break;
680  }
681  }
682 
683  return true;
684 }
685 
687  unsigned OpNo,
688  const char *ExtraCode,
689  raw_ostream &OS) {
690  // The current approach to inline asm is that "r" constraints are expressed
691  // as local indices, rather than values on the operand stack. This simplifies
692  // using "r" as it eliminates the need to push and pop the values in a
693  // particular order, however it also makes it impossible to have an "m"
694  // constraint. So we don't support it.
695 
696  return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
697 }
698 
699 // Force static initialization.
703 }
llvm::WebAssemblyTargetStreamer::emitLocal
virtual void emitLocal(ArrayRef< wasm::ValType > Types)=0
.local
llvm::wasm::WASM_FEATURE_PREFIX_USED
@ WASM_FEATURE_PREFIX_USED
Definition: Wasm.h:342
AsmPrinter.h
llvm::WebAssemblySubtarget::getRegisterInfo
const WebAssemblyRegisterInfo * getRegisterInfo() const override
Definition: WebAssemblySubtarget.h:82
llvm::WebAssemblyFeatureKV
const SubtargetFeatureKV WebAssemblyFeatureKV[WebAssembly::NumSubtargetFeatures]
llvm::wasm::WASM_FEATURE_PREFIX_DISALLOWED
@ WASM_FEATURE_PREFIX_DISALLOWED
Definition: Wasm.h:344
llvm::AsmPrinter::isPositionIndependent
bool isPositionIndependent() const
Definition: AsmPrinter.cpp:373
WasmKeepRegisters
cl::opt< bool > WasmKeepRegisters
MachineModuleInfoImpls.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:104
MachineInstr.h
llvm::MachineOperand::MO_Immediate
@ MO_Immediate
Immediate operand.
Definition: MachineOperand.h:52
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::WebAssemblyTargetStreamer
WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directive...
Definition: WebAssemblyTargetStreamer.h:29
llvm::wasm::ValType::I32
@ I32
llvm::AsmPrinter::printOffset
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
Definition: AsmPrinter.cpp:3299
WebAssembly.h
llvm::MCSymbol
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::WebAssemblyFunctionInfo::getLocals
const std::vector< MVT > & getLocals() const
Definition: WebAssemblyMachineFunctionInfo.h:95
llvm::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1477
llvm::SectionKind::getMetadata
static SectionKind getMetadata()
Definition: SectionKind.h:188
Metadata.h
llvm::AsmPrinter::lowerConstant
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
Definition: AsmPrinter.cpp:2673
llvm::getTheWebAssemblyTarget32
Target & getTheWebAssemblyTarget32()
Definition: WebAssemblyTargetInfo.cpp:20
llvm::MCSymbolWasm::getType
Optional< wasm::WasmSymbolType > getType() const
Definition: MCSymbolWasm.h:51
DebugInfoMetadata.h
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:160
llvm::MachineModuleInfoWasm::MachineSymbolsUsed
StringSet MachineSymbolsUsed
Definition: MachineModuleInfoImpls.h:113
llvm::Function
Definition: Function.h:60
llvm::MCContext::getSymbols
const SymbolTable & getSymbols() const
getSymbols - Get a reference for the symbol table for clients that want to, for example,...
Definition: MCContext.h:518
llvm::WebAssemblyTargetStreamer::emitIndIdx
virtual void emitIndIdx(const MCExpr *Value)=0
.indidx
llvm::WebAssemblySubtarget::getTargetLowering
const WebAssemblyTargetLowering * getTargetLowering() const override
Definition: WebAssemblySubtarget.h:76
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:87
llvm::MCConstantExpr::create
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)
Definition: MCExpr.cpp:194
llvm::WebAssembly::getOrCreateFunctionTableSymbol
MCSymbolWasm * getOrCreateFunctionTableSymbol(MCContext &Ctx, const WebAssemblySubtarget *Subtarget)
Returns the __indirect_function_table, for use in call_indirect and in function bitcasts.
Definition: WebAssemblyUtilities.cpp:125
llvm::signatureFromMVTs
std::unique_ptr< wasm::WasmSignature > signatureFromMVTs(const SmallVectorImpl< MVT > &Results, const SmallVectorImpl< MVT > &Params)
Definition: WebAssemblyMachineFunctionInfo.cpp:106
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
WebAssemblyMCInstLower.h
llvm::WebAssemblyAsmPrinter::PrintAsmMemoryOperand
bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
Definition: WebAssemblyAsmPrinter.cpp:686
isEmscriptenInvokeName
static bool isEmscriptenInvokeName(StringRef Name)
Definition: WebAssemblyAsmPrinter.cpp:102
llvm::WebAssemblyAsmPrinter::getSubtarget
const WebAssemblySubtarget & getSubtarget() const
Definition: WebAssemblyAsmPrinter.h:46
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::wasm::WASM_SYMBOL_TYPE_TABLE
@ WASM_SYMBOL_TYPE_TABLE
Definition: Wasm.h:386
llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL
@ WASM_SYMBOL_TYPE_GLOBAL
Definition: Wasm.h:383
llvm::WebAssembly::signatureToString
std::string signatureToString(const wasm::WasmSignature *Sig)
Definition: WebAssemblyTypeUtilities.cpp:115
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:232
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::AsmPrinter::PrintSymbolOperand
virtual void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &OS)
Print the MachineOperand as a symbol.
Definition: AsmPrinterInlineAsm.cpp:457
llvm::WebAssemblySubtarget::hasAddr64
bool hasAddr64() const
Definition: WebAssemblySubtarget.h:92
llvm::SmallSet
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:136
llvm::Optional< wasm::WasmSymbolType >
T
#define T
Definition: Mips16ISelLowering.cpp:341
llvm::WebAssemblyAsmPrinter::regToString
std::string regToString(const MachineOperand &MO)
Definition: WebAssemblyAsmPrinter.cpp:71
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:848
llvm::WebAssembly::wasmSymbolSetType
void wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT, const SmallVector< MVT, 1 > &VTs)
Sets a Wasm Symbol Type.
Definition: WebAssemblyTypeUtilities.cpp:171
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:893
WebAssemblyTargetMachine.h
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:119
llvm::MCInst
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:184
llvm::MVT::v2f64
@ v2f64
Definition: MachineValueType.h:172
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
llvm::WebAssemblyAsmPrinter::getOrCreateWasmSymbol
MCSymbol * getOrCreateWasmSymbol(StringRef Name)
Definition: WebAssemblyAsmPrinter.cpp:210
llvm::MachineOperand::getOffset
int64_t getOffset() const
Return the offset from the symbol in this operand.
Definition: MachineOperand.h:609
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1618
llvm::WebAssemblyTargetStreamer::emitImportModule
virtual void emitImportModule(const MCSymbolWasm *Sym, StringRef ImportModule)=0
.import_module
llvm::WebAssemblyMCInstLower
This class is used to lower an MachineInstr into an MCInst.
Definition: WebAssemblyMCInstLower.h:30
LLVM_DEBUG
#define LLVM_DEBUG(X)
Definition: Debug.h:101
llvm::AsmPrinter::emitGlobalVariable
virtual void emitGlobalVariable(const GlobalVariable *GV)
Emit the specified global variable to the .s file.
Definition: AsmPrinter.cpp:676
llvm::MachineOperand::MO_Register
@ MO_Register
Register operand.
Definition: MachineOperand.h:51
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::GlobalVariable::hasInitializer
bool hasInitializer() const
Definitions have initializers, declarations don't.
Definition: GlobalVariable.h:91
llvm::AsmPrinter::EmitToStreamer
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:401
llvm::ISD::INLINEASM
@ INLINEASM
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:1018
llvm::WebAssemblyTargetLowering
Definition: WebAssemblyISelLowering.h:43
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::MCSA_NoDeadStrip
@ MCSA_NoDeadStrip
.no_dead_strip (MachO)
Definition: MCDirectives.h:39
llvm::WebAssemblyTargetStreamer::emitFunctionType
virtual void emitFunctionType(const MCSymbolWasm *Sym)=0
.functype
llvm::MachineBasicBlock::getSymbol
MCSymbol * getSymbol() const
Return the MCSymbol for this basic block.
Definition: MachineBasicBlock.cpp:57
llvm::WebAssemblyTargetStreamer::emitExportName
virtual void emitExportName(const MCSymbolWasm *Sym, StringRef ExportName)=0
.export_name
llvm::WebAssemblyMCInstLower::lower
void lower(const MachineInstr *MI, MCInst &OutMI) const
Definition: WebAssemblyMCInstLower.cpp:186
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:241
llvm::dwarf::LanguageString
StringRef LanguageString(unsigned Language)
Definition: Dwarf.cpp:327
llvm::AsmPrinter::emitLinkage
virtual void emitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const
This emits linkage information about GVSym based on GV, if this is supported by the target.
Definition: AsmPrinter.cpp:609
llvm::wasm::ValType::F64
@ F64
llvm::WebAssemblyTargetStreamer::emitTableType
virtual void emitTableType(const MCSymbolWasm *Sym)=0
.tabletype
llvm::WebAssemblyTargetStreamer::emitImportName
virtual void emitImportName(const MCSymbolWasm *Sym, StringRef ImportName)=0
.import_name
llvm::MachineOperand::MO_GlobalAddress
@ MO_GlobalAddress
Address of a global value.
Definition: MachineOperand.h:61
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:546
llvm::AMDGPU::HSAMD::Kernel::Key::Language
constexpr char Language[]
Key for Kernel::Metadata::mLanguage.
Definition: AMDGPUMetadata.h:388
llvm::MCSectionWasm
This represents a section on wasm.
Definition: MCSectionWasm.h:26
llvm::AsmPrinter::OutStreamer
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:96
llvm::AsmPrinter::PrintAsmMemoryOperand
virtual bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant as...
Definition: AsmPrinterInlineAsm.cpp:509
MCSymbolWasm.h
llvm::MVT::f64
@ f64
Definition: MachineValueType.h:56
int
Clang compiles this i1 i64 store i64 i64 store i64 i64 store i64 i64 store i64 align Which gets codegen d xmm0 movaps rbp movaps rbp movaps rbp movaps rbp rbp rbp rbp rbp It would be better to have movq s of instead of the movaps s LLVM produces ret int
Definition: README.txt:536
llvm::WebAssemblyAsmPrinter::addSignature
void addSignature(std::unique_ptr< wasm::WasmSignature > &&Sig)
Definition: WebAssemblyAsmPrinter.h:47
MCContext.h
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::WebAssemblyAsmPrinter::getRegType
MVT getRegType(unsigned RegNo) const
Definition: WebAssemblyAsmPrinter.cpp:59
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:45
MCSymbol.h
llvm::WebAssembly::WasmEnableEmSjLj
cl::opt< bool > WasmEnableEmSjLj
llvm::wasm::ValType::F32
@ F32
WebAssemblyRuntimeLibcallSignatures.h
llvm::wasm::WasmGlobalType
Definition: Wasm.h:112
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:48
llvm::WebAssemblyAsmPrinter::emitJumpTableInfo
void emitJumpTableInfo() override
Print assembly representations of the jump tables used by the current function to the current output ...
Definition: WebAssemblyAsmPrinter.cpp:565
WebAssemblyTypeUtilities.h
llvm::AsmPrinter::CurrentFnSym
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:118
llvm::report_fatal_error
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:143
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION
@ WASM_SYMBOL_TYPE_FUNCTION
Definition: Wasm.h:381
llvm::wasm::ValType
ValType
Definition: Wasm.h:422
llvm::MCTargetStreamer
Target specific streamer interface.
Definition: MCStreamer.h:93
llvm::AsmPrinter::emitFunctionBodyStart
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:519
llvm::SubtargetFeatureKV
Used to provide key value pairs for feature and CPU bit flags.
Definition: MCSubtargetInfo.h:35
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::MCSymbol::print
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:58
llvm::MCContext::getWasmSection
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:638
X
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang", "erlang-compatible garbage collector")
WebAssemblyUtilities.h
WebAssemblyMCTargetDesc.h
llvm::MachineRegisterInfo::getRegClass
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
Definition: MachineRegisterInfo.h:642
llvm::WebAssemblyAsmPrinter::EmitTargetFeatures
void EmitTargetFeatures(Module &M)
Definition: WebAssemblyAsmPrinter.cpp:494
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:200
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
WebAssemblyTargetStreamer.h
llvm::WebAssemblyFunctionInfo::UnusedReg
static const unsigned UnusedReg
Definition: WebAssemblyMachineFunctionInfo.h:122
llvm::cl::opt< bool >
llvm::WebAssemblyAsmPrinter::emitFunctionBodyStart
void emitFunctionBodyStart() override
Targets can override this to emit stuff before the first basic block in the function.
Definition: WebAssemblyAsmPrinter.cpp:569
llvm::MVT::v16i8
@ v16i8
Definition: MachineValueType.h:80
llvm::wasm::WASM_TYPE_I32
@ WASM_TYPE_I32
Definition: Wasm.h:260
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:66
llvm::MVT::v2i64
@ v2i64
Definition: MachineValueType.h:118
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:228
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:577
LLVM_EXTERNAL_VISIBILITY
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:126
llvm::wasm::ValType::EXTERNREF
@ EXTERNREF
llvm::wasm::ValType::I64
@ I64
llvm::MCSymbolWasm
Definition: MCSymbolWasm.h:16
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::wasm::ValType::FUNCREF
@ FUNCREF
llvm::AsmPrinter::getSymbolPreferLocal
MCSymbol * getSymbolPreferLocal(const GlobalValue &GV) const
Similar to getSymbol() but preferred for references.
Definition: AsmPrinter.cpp:658
llvm::valTypesFromMVTs
void valTypesFromMVTs(const ArrayRef< MVT > &In, SmallVectorImpl< wasm::ValType > &Out)
Definition: WebAssemblyMachineFunctionInfo.cpp:99
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::getLibcallSignature
void getLibcallSignature(const WebAssemblySubtarget &Subtarget, RTLIB::Libcall LC, SmallVectorImpl< wasm::ValType > &Rets, SmallVectorImpl< wasm::ValType > &Params)
Definition: WebAssemblyRuntimeLibcallSignatures.cpp:516
WebAssemblyTargetInfo.h
llvm::wasm::WasmSignature::Returns
SmallVector< ValType, 1 > Returns
Definition: Wasm.h:433
Analysis.h
StringExtras.h
MachineConstantPool.h
llvm::WebAssemblyAsmPrinter::EmitProducerInfo
void EmitProducerInfo(Module &M)
Definition: WebAssemblyAsmPrinter.cpp:443
llvm::wasm::WASM_FEATURE_PREFIX_REQUIRED
@ WASM_FEATURE_PREFIX_REQUIRED
Definition: Wasm.h:343
llvm::MachineOperand::getType
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Definition: MachineOperand.h:218
llvm::wasm::WASM_SYMBOL_TYPE_TAG
@ WASM_SYMBOL_TYPE_TAG
Definition: Wasm.h:385
llvm::WebAssemblyFunctionInfo::getWAReg
unsigned getWAReg(unsigned VReg) const
Definition: WebAssemblyMachineFunctionInfo.h:150
llvm::Register::isVirtualRegister
static bool isVirtualRegister(unsigned Reg)
Return true if the specified register number is in the virtual register namespace.
Definition: Register.h:71
llvm::MVT::v4f32
@ v4f32
Definition: MachineValueType.h:157
llvm::WebAssemblyFunctionInfo::isVRegStackified
bool isVRegStackified(unsigned VReg) const
Definition: WebAssemblyMachineFunctionInfo.h:136
llvm::MachineFunction::getConstantPool
MachineConstantPool * getConstantPool()
getConstantPool - Return the constant pool object for the current function.
Definition: MachineFunction.h:672
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::wasm::WASM_TYPE_I64
@ WASM_TYPE_I64
Definition: Wasm.h:261
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:654
llvm::MVT::Other
@ Other
Definition: MachineValueType.h:42
llvm::Optional::getValue
constexpr const T & getValue() const &
Definition: Optional.h:279
llvm::GlobalValue::isThreadLocal
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:243
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:99
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:91
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:359
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:926
llvm::WebAssemblyAsmPrinter::emitDecls
void emitDecls(const Module &M)
Definition: WebAssemblyAsmPrinter.cpp:294
WebAssemblyMachineFunctionInfo.h
getInvokeSig
static char getInvokeSig(wasm::ValType VT)
Definition: WebAssemblyAsmPrinter.cpp:110
llvm::computeLegalValueVTs
void computeLegalValueVTs(const WebAssemblyTargetLowering &TLI, LLVMContext &Ctx, const DataLayout &DL, Type *Ty, SmallVectorImpl< MVT > &ValueVTs)
Definition: WebAssemblyMachineFunctionInfo.cpp:33
llvm::AsmPrinter::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition: AsmPrinter.cpp:3377
llvm::MachineOperand::getMBB
MachineBasicBlock * getMBB() const
Definition: MachineOperand.h:561
WebAssemblyAsmPrinter.h
DataLayout.h
llvm::MVT::i64
@ i64
Definition: MachineValueType.h:47
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
llvm::WebAssemblyAsmPrinter::PrintAsmOperand
bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS) override
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
Definition: WebAssemblyAsmPrinter.cpp:648
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::MachineModuleInfoWasm
MachineModuleInfoWasm - This is a MachineModuleInfoImpl implementation for Wasm targets.
Definition: MachineModuleInfoImpls.h:107
llvm::TargetRegisterInfo::isTypeLegalForClass
bool isTypeLegalForClass(const TargetRegisterClass &RC, MVT T) const
Return true if the given TargetRegisterClass has the ValueType T.
Definition: TargetRegisterInfo.h:292
llvm::MachineOperand::MO_MachineBasicBlock
@ MO_MachineBasicBlock
MachineBasicBlock reference.
Definition: MachineOperand.h:55
S
add sub stmia L5 ldr r0 bl L_printf $stub Instead of a and a wouldn t it be better to do three moves *Return an aggregate type is even return S
Definition: README.txt:210
llvm::WebAssemblySubtarget
Definition: WebAssemblySubtarget.h:35
llvm::MVT::v4i32
@ v4i32
Definition: MachineValueType.h:103
llvm::SmallSet::insert
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:182
LLVMInitializeWebAssemblyAsmPrinter
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmPrinter()
Definition: WebAssemblyAsmPrinter.cpp:700
llvm::Register
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
llvm::AsmPrinter::MMI
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:102
llvm::getTheWebAssemblyTarget64
Target & getTheWebAssemblyTarget64()
Definition: WebAssemblyTargetInfo.cpp:24
llvm::AMDGPU::SendMsg::Msg
const CustomOperand< const MCSubtargetInfo & > Msg[]
Definition: AMDGPUAsmUtils.cpp:39
llvm::WebAssemblyAsmPrinter::getTargetStreamer
WebAssemblyTargetStreamer * getTargetStreamer()
Definition: WebAssemblyAsmPrinter.cpp:81
llvm::WebAssemblyAsmPrinter::emitConstantPool
void emitConstantPool() override
Print to the current output stream assembly representations of the constants in the constant pool MCP...
Definition: WebAssemblyAsmPrinter.cpp:559
llvm::WebAssemblyAsmPrinter::emitInstruction
void emitInstruction(const MachineInstr *MI) override
Targets should implement this to emit instructions.
Definition: WebAssemblyAsmPrinter.cpp:598
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::computeSignatureVTs
void computeSignatureVTs(const FunctionType *Ty, const Function *TargetFunc, const Function &ContextFunc, const TargetMachine &TM, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results)
Definition: WebAssemblyMachineFunctionInfo.cpp:55
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:606
uint16_t
llvm::MachineConstantPool::getConstants
const std::vector< MachineConstantPoolEntry > & getConstants() const
Definition: MachineConstantPool.h:145
llvm::SectionName
Definition: DWARFSection.h:21
llvm::MachineOperand::MO_ExternalSymbol
@ MO_ExternalSymbol
Name of external global symbol.
Definition: MachineOperand.h:60
GlobalVariable.h
llvm::MVT::v8i16
@ v8i16
Definition: MachineValueType.h:92
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:262
WebAssemblyRegisterInfo.h
llvm::WebAssemblyAsmPrinter::emitGlobalVariable
void emitGlobalVariable(const GlobalVariable *GV) override
Emit the specified global variable to the .s file.
Definition: WebAssemblyAsmPrinter.cpp:172
llvm::MVT::i32
@ i32
Definition: MachineValueType.h:46
llvm::WebAssemblyAsmPrinter::getMCSymbolForFunction
MCSymbolWasm * getMCSymbolForFunction(const Function *F, bool EnableEmEH, wasm::WasmSignature *Sig, bool &InvokeDetected)
Definition: WebAssemblyAsmPrinter.cpp:150
llvm::AsmPrinter::emitVisibility
void emitVisibility(MCSymbol *Sym, unsigned Visibility, bool IsDefinition=true) const
This emits visibility information about symbol, if this is supported by the target.
Definition: AsmPrinter.cpp:3537
Wasm.h
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: Globals.cpp:117
llvm::wasm::ValType::V128
@ V128
llvm::WebAssemblyAsmPrinter::emitSymbolType
void emitSymbolType(const MCSymbolWasm *Sym)
Definition: WebAssemblyAsmPrinter.cpp:274
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:84
Version
uint64_t Version
Definition: RawMemProfReader.cpp:40
llvm::MachineOperand::getSymbolName
const char * getSymbolName() const
Definition: MachineOperand.h:617
llvm::WebAssembly::isWasmVarAddressSpace
bool isWasmVarAddressSpace(unsigned AS)
Definition: WebAssemblyTypeUtilities.h:63
MCStreamer.h
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:272
llvm::WebAssemblyTargetStreamer::emitTagType
virtual void emitTagType(const MCSymbolWasm *Sym)=0
.tagtype
llvm::OptimizedStructLayoutField
A field in a structure.
Definition: OptimizedStructLayout.h:45
llvm::RegisterAsmPrinter
RegisterAsmPrinter - Helper template for registering a target specific assembly printer,...
Definition: TargetRegistry.h:1359
llvm::MDString::getString
StringRef getString() const
Definition: Metadata.cpp:509
llvm::AsmPrinter::isVerbose
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:254
raw_ostream.h
llvm::MDString
A single uniqued string.
Definition: Metadata.h:612
TargetRegistry.h
CU
Definition: AArch64AsmBackend.cpp:505
llvm::MachineModuleInfo::getModule
const Module * getModule() const
Definition: MachineModuleInfo.h:151
llvm::MVT::f32
@ f32
Definition: MachineValueType.h:55
llvm::WebAssemblyTargetStreamer::emitGlobalType
virtual void emitGlobalType(const MCSymbolWasm *Sym)=0
.globaltype
llvm::wasm::WasmSignature::Params
SmallVector< ValType, 4 > Params
Definition: Wasm.h:434
Debug.h
getEmscriptenInvokeSymbolName
static std::string getEmscriptenInvokeSymbolName(wasm::WasmSignature *Sig)
Definition: WebAssemblyAsmPrinter.cpp:132
llvm::wasm::WASM_SYMBOL_TYPE_DATA
@ WASM_SYMBOL_TYPE_DATA
Definition: Wasm.h:382
llvm::AsmPrinter::PrintAsmOperand
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant.
Definition: AsmPrinterInlineAsm.cpp:467
llvm::MachineModuleInfo::getObjFileInfo
Ty & getObjFileInfo()
Keep track of various per-module pieces of information for backends that would like to do so.
Definition: MachineModuleInfo.h:171
llvm::WebAssembly::WasmEnableEmEH
cl::opt< bool > WasmEnableEmEH
llvm::wasm::WasmSignature
Definition: Wasm.h:432
llvm::WebAssemblyAsmPrinter::emitEndOfAsmFile
void emitEndOfAsmFile(Module &M) override
This virtual method can be overridden by targets that want to emit something at the end of their file...
Definition: WebAssemblyAsmPrinter.cpp:388
MCSectionWasm.h
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:927
SmallSet.h