LLVM  14.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/Support/Debug.h"
48 
49 using namespace llvm;
50 
51 #define DEBUG_TYPE "asm-printer"
52 
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);
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 
74  Register RegNo = MO.getReg();
76  "Unlowered physical register encountered during assembly printing");
77  assert(!MFI->isVRegStackified(RegNo));
78  unsigned WAReg = MFI->getWAReg(RegNo);
80  return '$' + utostr(WAReg);
81 }
82 
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.
105  if (Name.front() == '"' && Name.back() == '"')
106  Name = Name.substr(1, Name.size() - 2);
107  return Name.startswith("__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';
125  return 'F';
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.
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 
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()) + ": " +
164  report_fatal_error(Msg);
165  }
166  WasmSym = cast<MCSymbolWasm>(
168  } else {
169  WasmSym = cast<MCSymbolWasm>(getSymbol(F));
170  }
171  return WasmSym;
172 }
173 
177  return;
178  }
179 
180  assert(!GV->isThreadLocal());
181 
182  MCSymbolWasm *Sym = cast<MCSymbolWasm>(getSymbol(GV));
183 
184  if (!Sym->getType()) {
185  const WebAssemblyTargetLowering &TLI = *Subtarget->getTargetLowering();
188  VTs);
189  if (VTs.size() != 1 ||
190  TLI.getNumRegisters(GV->getParent()->getContext(), VTs[0]) != 1)
191  report_fatal_error("Aggregate globals not yet implemented");
192  MVT VT = TLI.getRegisterType(GV->getParent()->getContext(), VTs[0]);
193  bool Mutable = true;
196  Sym->setGlobalType(wasm::WasmGlobalType{uint8_t(Type), Mutable});
197  }
198 
199  emitVisibility(Sym, GV->getVisibility(), !GV->isDeclaration());
200  if (GV->hasInitializer()) {
201  assert(getSymbolPreferLocal(*GV) == Sym);
202  emitLinkage(GV, Sym);
204  OutStreamer->emitLabel(Sym);
205  // TODO: Actually emit the initializer value. Otherwise the global has the
206  // default value for its type (0, ref.null, etc).
207  OutStreamer->AddBlankLine();
208  }
209 }
210 
212  auto *WasmSym = cast<MCSymbolWasm>(GetExternalSymbolSymbol(Name));
213 
214  // May be called multiple times, so early out.
215  if (WasmSym->getType().hasValue())
216  return WasmSym;
217 
218  const WebAssemblySubtarget &Subtarget = getSubtarget();
219 
220  // Except for certain known symbols, all symbols used by CodeGen are
221  // functions. It's OK to hardcode knowledge of specific symbols here; this
222  // method is precisely there for fetching the signatures of known
223  // Clang-provided symbols.
224  if (Name == "__stack_pointer" || Name == "__tls_base" ||
225  Name == "__memory_base" || Name == "__table_base" ||
226  Name == "__tls_size" || Name == "__tls_align") {
227  bool Mutable =
228  Name == "__stack_pointer" || Name == "__tls_base";
229  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
230  WasmSym->setGlobalType(wasm::WasmGlobalType{
231  uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
233  Mutable});
234  return WasmSym;
235  }
236 
239  if (Name == "__cpp_exception" || Name == "__c_longjmp") {
240  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_TAG);
241  // We can't confirm its signature index for now because there can be
242  // imported exceptions. Set it to be 0 for now.
243  WasmSym->setTagType(
244  {wasm::WASM_TAG_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
245  // We may have multiple C++ compilation units to be linked together, each of
246  // which defines the exception symbol. To resolve them, we declare them as
247  // weak.
248  WasmSym->setWeak(true);
249  WasmSym->setExternal(true);
250 
251  // Currently both C++ exceptions and C longjmps have a single pointer type
252  // param. For C++ exceptions it is a pointer to an exception object, and for
253  // C longjmps it is pointer to a struct that contains a setjmp buffer and a
254  // longjmp return value. We may consider using multiple value parameters for
255  // longjmps later when multivalue support is ready.
256  wasm::ValType AddrType =
258  Params.push_back(AddrType);
259  } else { // Function symbols
260  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
261  getLibcallSignature(Subtarget, Name, Returns, Params);
262  }
263  auto Signature = std::make_unique<wasm::WasmSignature>(std::move(Returns),
264  std::move(Params));
265  WasmSym->setSignature(Signature.get());
266  addSignature(std::move(Signature));
267 
268  return WasmSym;
269 }
270 
272  if (signaturesEmitted)
273  return;
274  signaturesEmitted = true;
275 
276  // Normally symbols for globals get discovered as the MI gets lowered,
277  // but we need to know about them ahead of time.
279  for (const auto &Name : MMIW.MachineSymbolsUsed) {
280  getOrCreateWasmSymbol(Name.getKey());
281  }
282 
283  for (auto &It : OutContext.getSymbols()) {
284  // Emit .globaltype, .tagtype, or .tabletype declarations.
285  auto Sym = cast<MCSymbolWasm>(It.getValue());
286  if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_GLOBAL) {
287  // .globaltype already handled by emitGlobalVariable for defined
288  // variables; here we make sure the types of external wasm globals get
289  // written to the file.
290  if (Sym->isUndefined())
292  } else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TAG)
294  else if (Sym->getType() == wasm::WASM_SYMBOL_TYPE_TABLE)
296  }
297 
298  DenseSet<MCSymbol *> InvokeSymbols;
299  for (const auto &F : M) {
300  if (F.isIntrinsic())
301  continue;
302 
303  // Emit function type info for all undefined functions
304  if (F.isDeclarationForLinker()) {
306  SmallVector<MVT, 4> Params;
307  computeSignatureVTs(F.getFunctionType(), &F, F, TM, Params, Results);
308  // At this point these MCSymbols may or may not have been created already
309  // and thus also contain a signature, but we need to get the signature
310  // anyway here in case it is an invoke that has not yet been created. We
311  // will discard it later if it turns out not to be necessary.
312  auto Signature = signatureFromMVTs(Results, Params);
313  bool InvokeDetected = false;
315  Signature.get(), InvokeDetected);
316 
317  // Multiple functions can be mapped to the same invoke symbol. For
318  // example, two IR functions '__invoke_void_i8*' and '__invoke_void_i32'
319  // are both mapped to '__invoke_vi'. We keep them in a set once we emit an
320  // Emscripten EH symbol so we don't emit the same symbol twice.
321  if (InvokeDetected && !InvokeSymbols.insert(Sym).second)
322  continue;
323 
324  Sym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
325  if (!Sym->getSignature()) {
326  Sym->setSignature(Signature.get());
327  addSignature(std::move(Signature));
328  } else {
329  // This symbol has already been created and had a signature. Discard it.
330  Signature.reset();
331  }
332 
334 
335  if (F.hasFnAttribute("wasm-import-module")) {
336  StringRef Name =
337  F.getFnAttribute("wasm-import-module").getValueAsString();
338  Sym->setImportModule(storeName(Name));
340  }
341  if (F.hasFnAttribute("wasm-import-name")) {
342  // If this is a converted Emscripten EH/SjLj symbol, we shouldn't use
343  // the original function name but the converted symbol name.
344  StringRef Name =
345  InvokeDetected
346  ? Sym->getName()
347  : F.getFnAttribute("wasm-import-name").getValueAsString();
348  Sym->setImportName(storeName(Name));
350  }
351  }
352 
353  if (F.hasFnAttribute("wasm-export-name")) {
354  auto *Sym = cast<MCSymbolWasm>(getSymbol(&F));
355  StringRef Name = F.getFnAttribute("wasm-export-name").getValueAsString();
356  Sym->setExportName(storeName(Name));
358  }
359  }
360 }
361 
364 
365  // When a function's address is taken, a TABLE_INDEX relocation is emitted
366  // against the function symbol at the use site. However the relocation
367  // doesn't explicitly refer to the table. In the future we may want to
368  // define a new kind of reloc against both the function and the table, so
369  // that the linker can see that the function symbol keeps the table alive,
370  // but for now manually mark the table as live.
371  for (const auto &F : M) {
372  if (!F.isIntrinsic() && F.hasAddressTaken()) {
373  MCSymbolWasm *FunctionTable =
375  OutStreamer->emitSymbolAttribute(FunctionTable, MCSA_NoDeadStrip);
376  break;
377  }
378  }
379 
380  for (const auto &G : M.globals()) {
381  if (!G.hasInitializer() && G.hasExternalLinkage() &&
382  !WebAssembly::isWasmVarAddressSpace(G.getAddressSpace()) &&
383  G.getValueType()->isSized()) {
384  uint16_t Size = M.getDataLayout().getTypeAllocSize(G.getValueType());
385  OutStreamer->emitELFSize(getSymbol(&G),
387  }
388  }
389 
390  if (const NamedMDNode *Named = M.getNamedMetadata("wasm.custom_sections")) {
391  for (const Metadata *MD : Named->operands()) {
392  const auto *Tuple = dyn_cast<MDTuple>(MD);
393  if (!Tuple || Tuple->getNumOperands() != 2)
394  continue;
395  const MDString *Name = dyn_cast<MDString>(Tuple->getOperand(0));
396  const MDString *Contents = dyn_cast<MDString>(Tuple->getOperand(1));
397  if (!Name || !Contents)
398  continue;
399 
400  OutStreamer->PushSection();
401  std::string SectionName = (".custom_section." + Name->getString()).str();
402  MCSectionWasm *MySection =
404  OutStreamer->SwitchSection(MySection);
405  OutStreamer->emitBytes(Contents->getString());
406  OutStreamer->PopSection();
407  }
408  }
409 
412 }
413 
416  if (const NamedMDNode *Debug = M.getNamedMetadata("llvm.dbg.cu")) {
417  llvm::SmallSet<StringRef, 4> SeenLanguages;
418  for (size_t I = 0, E = Debug->getNumOperands(); I < E; ++I) {
419  const auto *CU = cast<DICompileUnit>(Debug->getOperand(I));
420  StringRef Language = dwarf::LanguageString(CU->getSourceLanguage());
421  Language.consume_front("DW_LANG_");
422  if (SeenLanguages.insert(Language).second)
423  Languages.emplace_back(Language.str(), "");
424  }
425  }
426 
428  if (const NamedMDNode *Ident = M.getNamedMetadata("llvm.ident")) {
430  for (size_t I = 0, E = Ident->getNumOperands(); I < E; ++I) {
431  const auto *S = cast<MDString>(Ident->getOperand(I)->getOperand(0));
432  std::pair<StringRef, StringRef> Field = S->getString().split("version");
433  StringRef Name = Field.first.trim();
434  StringRef Version = Field.second.trim();
435  if (SeenTools.insert(Name).second)
436  Tools.emplace_back(Name.str(), Version.str());
437  }
438  }
439 
440  int FieldCount = int(!Languages.empty()) + int(!Tools.empty());
441  if (FieldCount != 0) {
443  ".custom_section.producers", SectionKind::getMetadata());
444  OutStreamer->PushSection();
445  OutStreamer->SwitchSection(Producers);
446  OutStreamer->emitULEB128IntValue(FieldCount);
447  for (auto &Producers : {std::make_pair("language", &Languages),
448  std::make_pair("processed-by", &Tools)}) {
449  if (Producers.second->empty())
450  continue;
451  OutStreamer->emitULEB128IntValue(strlen(Producers.first));
452  OutStreamer->emitBytes(Producers.first);
453  OutStreamer->emitULEB128IntValue(Producers.second->size());
454  for (auto &Producer : *Producers.second) {
455  OutStreamer->emitULEB128IntValue(Producer.first.size());
456  OutStreamer->emitBytes(Producer.first);
457  OutStreamer->emitULEB128IntValue(Producer.second.size());
458  OutStreamer->emitBytes(Producer.second);
459  }
460  }
461  OutStreamer->PopSection();
462  }
463 }
464 
466  struct FeatureEntry {
467  uint8_t Prefix;
468  std::string Name;
469  };
470 
471  // Read target features and linkage policies from module metadata
472  SmallVector<FeatureEntry, 4> EmittedFeatures;
473  auto EmitFeature = [&](std::string Feature) {
474  std::string MDKey = (StringRef("wasm-feature-") + Feature).str();
475  Metadata *Policy = M.getModuleFlag(MDKey);
476  if (Policy == nullptr)
477  return;
478 
479  FeatureEntry Entry;
480  Entry.Prefix = 0;
481  Entry.Name = Feature;
482 
483  if (auto *MD = cast<ConstantAsMetadata>(Policy))
484  if (auto *I = cast<ConstantInt>(MD->getValue()))
485  Entry.Prefix = I->getZExtValue();
486 
487  // Silently ignore invalid metadata
488  if (Entry.Prefix != wasm::WASM_FEATURE_PREFIX_USED &&
489  Entry.Prefix != wasm::WASM_FEATURE_PREFIX_REQUIRED &&
490  Entry.Prefix != wasm::WASM_FEATURE_PREFIX_DISALLOWED)
491  return;
492 
493  EmittedFeatures.push_back(Entry);
494  };
495 
496  for (const SubtargetFeatureKV &KV : WebAssemblyFeatureKV) {
497  EmitFeature(KV.Key);
498  }
499  // This pseudo-feature tells the linker whether shared memory would be safe
500  EmitFeature("shared-mem");
501 
502  if (EmittedFeatures.size() == 0)
503  return;
504 
505  // Emit features and linkage policies into the "target_features" section
506  MCSectionWasm *FeaturesSection = OutContext.getWasmSection(
507  ".custom_section.target_features", SectionKind::getMetadata());
508  OutStreamer->PushSection();
509  OutStreamer->SwitchSection(FeaturesSection);
510 
511  OutStreamer->emitULEB128IntValue(EmittedFeatures.size());
512  for (auto &F : EmittedFeatures) {
513  OutStreamer->emitIntValue(F.Prefix, 1);
514  OutStreamer->emitULEB128IntValue(F.Name.size());
515  OutStreamer->emitBytes(F.Name);
516  }
517 
518  OutStreamer->PopSection();
519 }
520 
522  assert(MF->getConstantPool()->getConstants().empty() &&
523  "WebAssembly disables constant pools");
524 }
525 
527  // Nothing to do; jump tables are incorporated into the instruction stream.
528 }
529 
531  const {
532  AsmPrinter::emitLinkage(GV, Sym);
533  // This gets called before the function label and type are emitted.
534  // We use it to emit signatures of external functions.
535  // FIXME casts!
536  const_cast<WebAssemblyAsmPrinter *>(this)
538 }
539 
540 
542  const Function &F = MF->getFunction();
543  SmallVector<MVT, 1> ResultVTs;
544  SmallVector<MVT, 4> ParamVTs;
545  computeSignatureVTs(F.getFunctionType(), &F, F, TM, ParamVTs, ResultVTs);
546 
547  auto Signature = signatureFromMVTs(ResultVTs, ParamVTs);
548  auto *WasmSym = cast<MCSymbolWasm>(CurrentFnSym);
549  WasmSym->setSignature(Signature.get());
550  addSignature(std::move(Signature));
551  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
552 
554 
555  // Emit the function index.
556  if (MDNode *Idx = F.getMetadata("wasm.index")) {
557  assert(Idx->getNumOperands() == 1);
558 
560  cast<ConstantAsMetadata>(Idx->getOperand(0))->getValue()));
561  }
562 
564  valTypesFromMVTs(MFI->getLocals(), Locals);
565  getTargetStreamer()->emitLocal(Locals);
566 
568 }
569 
571  LLVM_DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
572 
573  switch (MI->getOpcode()) {
574  case WebAssembly::ARGUMENT_i32:
575  case WebAssembly::ARGUMENT_i32_S:
576  case WebAssembly::ARGUMENT_i64:
577  case WebAssembly::ARGUMENT_i64_S:
578  case WebAssembly::ARGUMENT_f32:
579  case WebAssembly::ARGUMENT_f32_S:
580  case WebAssembly::ARGUMENT_f64:
581  case WebAssembly::ARGUMENT_f64_S:
582  case WebAssembly::ARGUMENT_v16i8:
583  case WebAssembly::ARGUMENT_v16i8_S:
584  case WebAssembly::ARGUMENT_v8i16:
585  case WebAssembly::ARGUMENT_v8i16_S:
586  case WebAssembly::ARGUMENT_v4i32:
587  case WebAssembly::ARGUMENT_v4i32_S:
588  case WebAssembly::ARGUMENT_v2i64:
589  case WebAssembly::ARGUMENT_v2i64_S:
590  case WebAssembly::ARGUMENT_v4f32:
591  case WebAssembly::ARGUMENT_v4f32_S:
592  case WebAssembly::ARGUMENT_v2f64:
593  case WebAssembly::ARGUMENT_v2f64_S:
594  // These represent values which are live into the function entry, so there's
595  // no instruction to emit.
596  break;
597  case WebAssembly::FALLTHROUGH_RETURN: {
598  // These instructions represent the implicit return at the end of a
599  // function body.
600  if (isVerbose()) {
601  OutStreamer->AddComment("fallthrough-return");
602  OutStreamer->AddBlankLine();
603  }
604  break;
605  }
606  case WebAssembly::COMPILER_FENCE:
607  // This is a compiler barrier that prevents instruction reordering during
608  // backend compilation, and should not be emitted.
609  break;
610  default: {
611  WebAssemblyMCInstLower MCInstLowering(OutContext, *this);
612  MCInst TmpInst;
613  MCInstLowering.lower(MI, TmpInst);
614  EmitToStreamer(*OutStreamer, TmpInst);
615  break;
616  }
617  }
618 }
619 
621  unsigned OpNo,
622  const char *ExtraCode,
623  raw_ostream &OS) {
624  // First try the generic code, which knows about modifiers like 'c' and 'n'.
625  if (!AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS))
626  return false;
627 
628  if (!ExtraCode) {
629  const MachineOperand &MO = MI->getOperand(OpNo);
630  switch (MO.getType()) {
632  OS << MO.getImm();
633  return false;
635  // FIXME: only opcode that still contains registers, as required by
636  // MachineInstr::getDebugVariable().
637  assert(MI->getOpcode() == WebAssembly::INLINEASM);
638  OS << regToString(MO);
639  return false;
641  PrintSymbolOperand(MO, OS);
642  return false;
645  printOffset(MO.getOffset(), OS);
646  return false;
648  MO.getMBB()->getSymbol()->print(OS, MAI);
649  return false;
650  default:
651  break;
652  }
653  }
654 
655  return true;
656 }
657 
659  unsigned OpNo,
660  const char *ExtraCode,
661  raw_ostream &OS) {
662  // The current approach to inline asm is that "r" constraints are expressed
663  // as local indices, rather than values on the operand stack. This simplifies
664  // using "r" as it eliminates the need to push and pop the values in a
665  // particular order, however it also makes it impossible to have an "m"
666  // constraint. So we don't support it.
667 
668  return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, ExtraCode, OS);
669 }
670 
671 // Force static initialization.
675 }
llvm::wasm::WASM_FEATURE_PREFIX_REQUIRED
@ WASM_FEATURE_PREFIX_REQUIRED
Definition: Wasm.h:330
llvm::Check::Size
@ Size
Definition: FileCheck.h:73
llvm::WebAssemblyTargetStreamer::emitLocal
virtual void emitLocal(ArrayRef< wasm::ValType > Types)=0
.local
llvm::wasm::WASM_TYPE_I64
@ WASM_TYPE_I64
Definition: Wasm.h:253
AsmPrinter.h
llvm::WebAssemblySubtarget::getRegisterInfo
const WebAssemblyRegisterInfo * getRegisterInfo() const override
Definition: WebAssemblySubtarget.h:81
llvm::WebAssemblyFeatureKV
const SubtargetFeatureKV WebAssemblyFeatureKV[WebAssembly::NumSubtargetFeatures]
WasmKeepRegisters
cl::opt< bool > WasmKeepRegisters
MachineModuleInfoImpls.h
MI
IRTranslator LLVM IR MI
Definition: IRTranslator.cpp:103
MachineInstr.h
llvm::MachineOperand::MO_Immediate
@ MO_Immediate
Immediate operand.
Definition: MachineOperand.h:53
llvm
---------------------— PointerInfo ------------------------------------—
Definition: AllocatorList.h:23
llvm::WebAssemblyTargetStreamer
WebAssembly-specific streamer interface, to implement support WebAssembly-specific assembly directive...
Definition: WebAssemblyTargetStreamer.h:29
llvm::wasm::ValType::I32
@ I32
WasmEnableEmEH
cl::opt< bool > WasmEnableEmEH
llvm::AsmPrinter::printOffset
void printOffset(int64_t Offset, raw_ostream &OS) const
This is just convenient handler for printing offsets.
Definition: AsmPrinter.cpp:3095
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:1396
llvm::SectionKind::getMetadata
static SectionKind getMetadata()
Definition: SectionKind.h:182
Metadata.h
llvm::AsmPrinter::lowerConstant
virtual const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
Definition: AsmPrinter.cpp:2472
llvm::getTheWebAssemblyTarget32
Target & getTheWebAssemblyTarget32()
Definition: WebAssemblyTargetInfo.cpp:20
llvm::MCSymbolWasm::getType
Optional< wasm::WasmSymbolType > getType() const
Definition: MCSymbolWasm.h:52
DebugInfoMetadata.h
llvm::cl::Prefix
@ Prefix
Definition: CommandLine.h:164
llvm::MachineModuleInfoWasm::MachineSymbolsUsed
StringSet MachineSymbolsUsed
Definition: MachineModuleInfoImpls.h:113
T
llvm::Function
Definition: Function.h:61
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:502
llvm::WebAssemblyTargetStreamer::emitIndIdx
virtual void emitIndIdx(const MCExpr *Value)=0
.indidx
llvm::WebAssemblySubtarget::getTargetLowering
const WebAssemblyTargetLowering * getTargetLowering() const override
Definition: WebAssemblySubtarget.h:75
llvm::AsmPrinter::MAI
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:88
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:100
llvm::signatureFromMVTs
std::unique_ptr< wasm::WasmSignature > signatureFromMVTs(const SmallVectorImpl< MVT > &Results, const SmallVectorImpl< MVT > &Params)
Definition: WebAssemblyMachineFunctionInfo.cpp:100
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
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:658
isEmscriptenInvokeName
static bool isEmscriptenInvokeName(StringRef Name)
Definition: WebAssemblyAsmPrinter.cpp:104
llvm::WebAssemblyAsmPrinter::getSubtarget
const WebAssemblySubtarget & getSubtarget() const
Definition: WebAssemblyAsmPrinter.h:46
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::wasm::WASM_SYMBOL_TYPE_TABLE
@ WASM_SYMBOL_TYPE_TABLE
Definition: Wasm.h:372
llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL
@ WASM_SYMBOL_TYPE_GLOBAL
Definition: Wasm.h:369
llvm::WebAssembly::signatureToString
std::string signatureToString(const wasm::WasmSignature *Sig)
Definition: WebAssemblyTypeUtilities.cpp:122
llvm::TargetRegisterInfo
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
Definition: TargetRegisterInfo.h:233
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:589
llvm::WebAssemblySubtarget::hasAddr64
bool hasAddr64() const
Definition: WebAssemblySubtarget.h:91
llvm::SmallSet
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:134
llvm::WebAssemblyAsmPrinter::regToString
std::string regToString(const MachineOperand &MO)
Definition: WebAssemblyAsmPrinter.cpp:73
Results
Function Alias Analysis Results
Definition: AliasAnalysis.cpp:847
llvm::WebAssemblyAsmPrinter::emitLinkage
void emitLinkage(const GlobalValue *, MCSymbol *) const override
This emits linkage information about GVSym based on GV, if this is supported by the target.
Definition: WebAssemblyAsmPrinter.cpp:530
llvm::errs
raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
Definition: raw_ostream.cpp:892
WebAssemblyTargetMachine.h
llvm::MipsISD::Ret
@ Ret
Definition: MipsISelLowering.h:116
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:211
llvm::MachineOperand::getOffset
int64_t getOffset() const
Return the offset from the symbol in this operand.
Definition: MachineOperand.h:600
TRI
unsigned const TargetRegisterInfo * TRI
Definition: MachineSink.cpp:1567
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:508
llvm::MachineOperand::MO_Register
@ MO_Register
Register operand.
Definition: MachineOperand.h:52
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::GlobalVariable::hasInitializer
bool hasInitializer() const
Definitions have initializers, declarations don't.
Definition: GlobalVariable.h:92
llvm::AsmPrinter::EmitToStreamer
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:243
llvm::ComputeValueVTs
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
Definition: Analysis.cpp:124
llvm::ISD::INLINEASM
@ INLINEASM
INLINEASM - Represents an inline asm block.
Definition: ISDOpcodes.h:980
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:38
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:60
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:190
llvm::wasm::WASM_FEATURE_PREFIX_DISALLOWED
@ WASM_FEATURE_PREFIX_DISALLOWED
Definition: Wasm.h:331
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:228
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:441
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:62
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
llvm::MachineOperand::getImm
int64_t getImm() const
Definition: MachineOperand.h:537
llvm::AMDGPU::HSAMD::Kernel::Key::Language
constexpr char Language[]
Key for Kernel::Metadata::mLanguage.
Definition: AMDGPUMetadata.h:383
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:97
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:641
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
llvm::wasm::WASM_FEATURE_PREFIX_USED
@ WASM_FEATURE_PREFIX_USED
Definition: Wasm.h:329
Y
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml", "ocaml 3.10-compatible collector")
llvm::WebAssemblyAsmPrinter::getRegType
MVT getRegType(unsigned RegNo) const
Definition: WebAssemblyAsmPrinter.cpp:61
llvm::TargetRegisterClass
Definition: TargetRegisterInfo.h:46
MCSymbol.h
llvm::wasm::ValType::F32
@ F32
llvm::WebAssembly::toValType
wasm::ValType toValType(MVT Type)
Definition: WebAssemblyTypeUtilities.cpp:131
WebAssemblyRuntimeLibcallSignatures.h
llvm::wasm::WasmGlobalType
Definition: Wasm.h:98
llvm::MachineOperand
MachineOperand class - Representation of each machine instruction operand.
Definition: MachineOperand.h:49
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:526
llvm::MCSymbolWasm::setType
void setType(wasm::WasmSymbolType type)
Definition: MCSymbolWasm.h:54
WebAssemblyTypeUtilities.h
llvm::AsmPrinter::CurrentFnSym
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:119
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:140
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:53
llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION
@ WASM_SYMBOL_TYPE_FUNCTION
Definition: Wasm.h:367
llvm::wasm::ValType
ValType
Definition: Wasm.h:408
llvm::IndexedInstrProf::Version
const uint64_t Version
Definition: InstrProf.h:991
llvm::MCTargetStreamer
Target specific streamer interface.
Definition: MCStreamer.h:91
llvm::AsmPrinter::emitFunctionBodyStart
virtual void emitFunctionBodyStart()
Targets can override this to emit stuff before the first basic block in the function.
Definition: AsmPrinter.h:483
llvm::SubtargetFeatureKV
Used to provide key value pairs for feature and CPU bit flags.
Definition: MCSubtargetInfo.h:34
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:59
llvm::MCContext::getWasmSection
MCSectionWasm * getWasmSection(const Twine &Section, SectionKind K, unsigned Flags=0)
Definition: MCContext.h:621
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:634
llvm::WebAssemblyAsmPrinter::EmitTargetFeatures
void EmitTargetFeatures(Module &M)
Definition: WebAssemblyAsmPrinter.cpp:465
llvm::wasm::WASM_TAG_ATTRIBUTE_EXCEPTION
@ WASM_TAG_ATTRIBUTE_EXCEPTION
Definition: Wasm.h:382
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
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:541
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::MVT::v16i8
@ v16i8
Definition: MachineValueType.h:80
llvm::MachineInstr
Representation of each machine instruction.
Definition: MachineInstr.h:64
llvm::MVT::v2i64
@ v2i64
Definition: MachineValueType.h:118
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:229
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:572
LLVM_EXTERNAL_VISIBILITY
#define LLVM_EXTERNAL_VISIBILITY
Definition: Compiler.h:132
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:490
llvm::valTypesFromMVTs
void valTypesFromMVTs(const ArrayRef< MVT > &In, SmallVectorImpl< wasm::ValType > &Out)
Definition: WebAssemblyMachineFunctionInfo.cpp:93
I
#define I(x, y, z)
Definition: MD5.cpp:59
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:419
Analysis.h
StringExtras.h
MachineConstantPool.h
llvm::WebAssemblyAsmPrinter::EmitProducerInfo
void EmitProducerInfo(Module &M)
Definition: WebAssemblyAsmPrinter.cpp:414
llvm::MachineOperand::getType
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Definition: MachineOperand.h:219
llvm::wasm::WASM_SYMBOL_TYPE_TAG
@ WASM_SYMBOL_TYPE_TAG
Definition: Wasm.h:371
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:658
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::AsmPrinter::getSymbol
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:486
llvm::wasm::WASM_TYPE_I32
@ WASM_TYPE_I32
Definition: Wasm.h:252
llvm::MVT::Other
@ Other
Definition: MachineValueType.h:42
llvm::WebAssemblyAsmPrinter::emitExternalDecls
void emitExternalDecls(const Module &M)
Definition: WebAssemblyAsmPrinter.cpp:271
llvm::GlobalValue::isThreadLocal
bool isThreadLocal() const
If the value is "Thread Local", its value isn't shared by the threads.
Definition: GlobalValue.h:244
llvm::AsmPrinter::MF
MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:100
llvm::AsmPrinter::OutContext
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:92
llvm::MVT
Machine Value Type.
Definition: MachineValueType.h:31
llvm::MachineOperand::getReg
Register getReg() const
getReg - Returns the register number.
Definition: MachineOperand.h:360
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:906
llvm::WebAssemblyAsmPrinter
Definition: WebAssemblyAsmPrinter.h:21
WebAssemblyMachineFunctionInfo.h
getInvokeSig
static char getInvokeSig(wasm::ValType VT)
Definition: WebAssemblyAsmPrinter.cpp:112
llvm::AsmPrinter::GetExternalSymbolSymbol
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
Definition: AsmPrinter.cpp:3172
llvm::MachineOperand::getMBB
MachineBasicBlock * getMBB() const
Definition: MachineOperand.h:552
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:620
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:136
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:293
llvm::MachineOperand::MO_MachineBasicBlock
@ MO_MachineBasicBlock
MachineBasicBlock reference.
Definition: MachineOperand.h:56
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:180
LLVMInitializeWebAssemblyAsmPrinter
LLVM_EXTERNAL_VISIBILITY void LLVMInitializeWebAssemblyAsmPrinter()
Definition: WebAssemblyAsmPrinter.cpp:672
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:103
llvm::getTheWebAssemblyTarget64
Target & getTheWebAssemblyTarget64()
Definition: WebAssemblyTargetInfo.cpp:24
llvm::WebAssemblyAsmPrinter::getTargetStreamer
WebAssemblyTargetStreamer * getTargetStreamer()
Definition: WebAssemblyAsmPrinter.cpp:83
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:521
llvm::WebAssemblyAsmPrinter::emitInstruction
void emitInstruction(const MachineInstr *MI) override
Targets should implement this to emit instructions.
Definition: WebAssemblyAsmPrinter.cpp:570
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:49
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::MachineFunction::getFunction
Function & getFunction()
Return the LLVM function that this machine code represents.
Definition: MachineFunction.h:592
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:61
GlobalVariable.h
llvm::MVT::v8i16
@ v8i16
Definition: MachineValueType.h:92
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:261
WebAssemblyRegisterInfo.h
llvm::WebAssemblyAsmPrinter::emitGlobalVariable
void emitGlobalVariable(const GlobalVariable *GV) override
Emit the specified global variable to the .s file.
Definition: WebAssemblyAsmPrinter.cpp:174
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:152
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:3332
Wasm.h
llvm::GlobalValue::getAddressSpace
unsigned getAddressSpace() const
Definition: Globals.cpp:112
llvm::wasm::ValType::V128
@ V128
llvm::AsmPrinter::TM
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:85
llvm::MCSymbolWasm::setGlobalType
void setGlobalType(wasm::WasmGlobalType GT)
Definition: MCSymbolWasm.h:136
llvm::MachineOperand::getSymbolName
const char * getSymbolName() const
Definition: MachineOperand.h:608
llvm::WebAssembly::isWasmVarAddressSpace
bool isWasmVarAddressSpace(unsigned AS)
Definition: WebAssemblyUtilities.h:44
MCStreamer.h
WasmEnableEmSjLj
cl::opt< bool > WasmEnableEmSjLj
llvm::TargetLoweringBase::getRegisterType
MVT getRegisterType(MVT VT) const
Return the type of registers that this ValueType will eventually require.
Definition: TargetLowering.h:1460
llvm::TargetLoweringBase::getNumRegisters
virtual unsigned getNumRegisters(LLVMContext &Context, EVT VT, Optional< MVT > RegisterVT=None) const
Return the number of registers that this ValueType will eventually require.
Definition: TargetLowering.h:1498
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:401
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:273
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:1338
llvm::MDString::getString
StringRef getString() const
Definition: Metadata.cpp:483
llvm::AsmPrinter::isVerbose
bool isVerbose() const
Return true if assembly output should contain comments.
Definition: AsmPrinter.h:238
raw_ostream.h
llvm::MDString
A single uniqued string.
Definition: Metadata.h:611
TargetRegistry.h
CU
Definition: AArch64AsmBackend.cpp:501
llvm::MachineModuleInfo::getModule
const Module * getModule() const
Definition: MachineModuleInfo.h:174
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:420
Debug.h
getEmscriptenInvokeSymbolName
static std::string getEmscriptenInvokeSymbolName(wasm::WasmSignature *Sig)
Definition: WebAssemblyAsmPrinter.cpp:134
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:599
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:191
llvm::wasm::WasmSignature
Definition: Wasm.h:418
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:362
MCSectionWasm.h
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:908
SmallSet.h