1 //===-- WebAssemblyAsmPrinter.cpp - WebAssembly LLVM assembly writer ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file contains a printer that converts from our internal
12 /// representation of machine-dependent LLVM code to the WebAssembly assembly
15 //===----------------------------------------------------------------------===//
17 #include "WebAssemblyAsmPrinter.h"
18 #include "InstPrinter/WebAssemblyInstPrinter.h"
19 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
20 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
21 #include "WebAssembly.h"
22 #include "WebAssemblyMCInstLower.h"
23 #include "WebAssemblyMachineFunctionInfo.h"
24 #include "WebAssemblyRegisterInfo.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/CodeGen/Analysis.h"
27 #include "llvm/CodeGen/AsmPrinter.h"
28 #include "llvm/CodeGen/MachineConstantPool.h"
29 #include "llvm/CodeGen/MachineInstr.h"
30 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/GlobalVariable.h"
33 #include "llvm/MC/MCContext.h"
34 #include "llvm/MC/MCStreamer.h"
35 #include "llvm/MC/MCSymbol.h"
36 #include "llvm/Support/Debug.h"
37 #include "llvm/Support/TargetRegistry.h"
38 #include "llvm/Support/raw_ostream.h"
41 #define DEBUG_TYPE "asm-printer"
43 //===----------------------------------------------------------------------===//
45 //===----------------------------------------------------------------------===//
47 MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const {
48 const TargetRegisterInfo *TRI = Subtarget->getRegisterInfo();
49 const TargetRegisterClass *TRC = MRI->getRegClass(RegNo);
50 for (MVT T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64, MVT::v16i8, MVT::v8i16,
51 MVT::v4i32, MVT::v4f32})
52 if (TRI->isTypeLegalForClass(*TRC, T))
54 DEBUG(errs() << "Unknown type for register number: " << RegNo);
55 llvm_unreachable("Unknown register type");
59 std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
60 unsigned RegNo = MO.getReg();
61 assert(TargetRegisterInfo::isVirtualRegister(RegNo) &&
62 "Unlowered physical register encountered during assembly printing");
63 assert(!MFI->isVRegStackified(RegNo));
64 unsigned WAReg = MFI->getWAReg(RegNo);
65 assert(WAReg != WebAssemblyFunctionInfo::UnusedReg);
66 return '$' + utostr(WAReg);
69 WebAssemblyTargetStreamer *WebAssemblyAsmPrinter::getTargetStreamer() {
70 MCTargetStreamer *TS = OutStreamer->getTargetStreamer();
71 return static_cast<WebAssemblyTargetStreamer *>(TS);
74 //===----------------------------------------------------------------------===//
75 // WebAssemblyAsmPrinter Implementation.
76 //===----------------------------------------------------------------------===//
78 void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) {
79 for (const auto &F : M) {
80 // Emit function type info for all undefined functions
81 if (F.isDeclarationForLinker() && !F.isIntrinsic()) {
82 SmallVector<MVT, 4> Results;
83 SmallVector<MVT, 4> Params;
84 ComputeSignatureVTs(F, TM, Params, Results);
85 getTargetStreamer()->emitIndirectFunctionType(F.getName(), Params,
89 for (const auto &G : M.globals()) {
90 if (!G.hasInitializer() && G.hasExternalLinkage()) {
91 uint16_t Size = M.getDataLayout().getTypeAllocSize(G.getValueType());
92 getTargetStreamer()->emitGlobalImport(G.getGlobalIdentifier());
93 OutStreamer->emitELFSize(getSymbol(&G),
94 MCConstantExpr::create(Size, OutContext));
98 if (!TM.getTargetTriple().isOSBinFormatELF()) {
99 MachineModuleInfoWasm &MMIW = MMI->getObjFileInfo<MachineModuleInfoWasm>();
100 getTargetStreamer()->emitGlobal(MMIW.getGlobals());
101 if (MMIW.hasStackPointerGlobal())
102 getTargetStreamer()->emitStackPointer(MMIW.getStackPointerGlobal());
106 void WebAssemblyAsmPrinter::EmitConstantPool() {
107 assert(MF->getConstantPool()->getConstants().empty() &&
108 "WebAssembly disables constant pools");
111 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
112 // Nothing to do; jump tables are incorporated into the instruction stream.
115 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
116 getTargetStreamer()->emitParam(CurrentFnSym, MFI->getParams());
118 SmallVector<MVT, 4> ResultVTs;
119 const Function &F(*MF->getFunction());
121 // Emit the function index.
122 if (MDNode *Idx = F.getMetadata("wasm.index")) {
123 assert(Idx->getNumOperands() == 1);
125 getTargetStreamer()->emitIndIdx(AsmPrinter::lowerConstant(
126 cast<ConstantAsMetadata>(Idx->getOperand(0))->getValue()));
129 ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs);
131 // If the return type needs to be legalized it will get converted into
132 // passing a pointer.
133 if (ResultVTs.size() == 1)
134 getTargetStreamer()->emitResult(CurrentFnSym, ResultVTs);
136 getTargetStreamer()->emitResult(CurrentFnSym, ArrayRef<MVT>());
138 if (TM.getTargetTriple().isOSBinFormatELF()) {
139 assert(MFI->getLocals().empty());
140 for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) {
141 unsigned VReg = TargetRegisterInfo::index2VirtReg(Idx);
142 unsigned WAReg = MFI->getWAReg(VReg);
143 // Don't declare unused registers.
144 if (WAReg == WebAssemblyFunctionInfo::UnusedReg)
146 // Don't redeclare parameters.
147 if (WAReg < MFI->getParams().size())
149 // Don't declare stackified registers.
152 MFI->addLocal(getRegType(VReg));
156 getTargetStreamer()->emitLocal(MFI->getLocals());
158 AsmPrinter::EmitFunctionBodyStart();
161 void WebAssemblyAsmPrinter::EmitFunctionBodyEnd() {
162 if (TM.getTargetTriple().isOSBinFormatELF())
163 getTargetStreamer()->emitEndFunc();
166 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
167 DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
169 switch (MI->getOpcode()) {
170 case WebAssembly::ARGUMENT_I32:
171 case WebAssembly::ARGUMENT_I64:
172 case WebAssembly::ARGUMENT_F32:
173 case WebAssembly::ARGUMENT_F64:
174 case WebAssembly::ARGUMENT_v16i8:
175 case WebAssembly::ARGUMENT_v8i16:
176 case WebAssembly::ARGUMENT_v4i32:
177 case WebAssembly::ARGUMENT_v4f32:
178 // These represent values which are live into the function entry, so there's
179 // no instruction to emit.
181 case WebAssembly::FALLTHROUGH_RETURN_I32:
182 case WebAssembly::FALLTHROUGH_RETURN_I64:
183 case WebAssembly::FALLTHROUGH_RETURN_F32:
184 case WebAssembly::FALLTHROUGH_RETURN_F64:
185 case WebAssembly::FALLTHROUGH_RETURN_v16i8:
186 case WebAssembly::FALLTHROUGH_RETURN_v8i16:
187 case WebAssembly::FALLTHROUGH_RETURN_v4i32:
188 case WebAssembly::FALLTHROUGH_RETURN_v4f32: {
189 // These instructions represent the implicit return at the end of a
190 // function body. The operand is always a pop.
191 assert(MFI->isVRegStackified(MI->getOperand(0).getReg()));
194 OutStreamer->AddComment("fallthrough-return: $pop" +
195 utostr(MFI->getWARegStackId(
196 MFI->getWAReg(MI->getOperand(0).getReg()))));
197 OutStreamer->AddBlankLine();
201 case WebAssembly::FALLTHROUGH_RETURN_VOID:
202 // This instruction represents the implicit return at the end of a
203 // function body with no return value.
205 OutStreamer->AddComment("fallthrough-return");
206 OutStreamer->AddBlankLine();
210 WebAssemblyMCInstLower MCInstLowering(OutContext, *this);
212 MCInstLowering.Lower(MI, TmpInst);
213 EmitToStreamer(*OutStreamer, TmpInst);
219 const MCExpr *WebAssemblyAsmPrinter::lowerConstant(const Constant *CV) {
220 if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
221 if (GV->getValueType()->isFunctionTy())
222 return MCSymbolRefExpr::create(
223 getSymbol(GV), MCSymbolRefExpr::VK_WebAssembly_FUNCTION, OutContext);
224 return AsmPrinter::lowerConstant(CV);
227 bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
228 unsigned OpNo, unsigned AsmVariant,
229 const char *ExtraCode,
232 report_fatal_error("There are no defined alternate asm variants");
234 // First try the generic code, which knows about modifiers like 'c' and 'n'.
235 if (!AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS))
239 const MachineOperand &MO = MI->getOperand(OpNo);
240 switch (MO.getType()) {
241 case MachineOperand::MO_Immediate:
244 case MachineOperand::MO_Register:
245 OS << regToString(MO);
247 case MachineOperand::MO_GlobalAddress:
248 getSymbol(MO.getGlobal())->print(OS, MAI);
249 printOffset(MO.getOffset(), OS);
251 case MachineOperand::MO_ExternalSymbol:
252 GetExternalSymbolSymbol(MO.getSymbolName())->print(OS, MAI);
253 printOffset(MO.getOffset(), OS);
255 case MachineOperand::MO_MachineBasicBlock:
256 MO.getMBB()->getSymbol()->print(OS, MAI);
266 bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
269 const char *ExtraCode,
272 report_fatal_error("There are no defined alternate asm variants");
275 // TODO: For now, we just hard-code 0 as the constant offset; teach
276 // SelectInlineAsmMemoryOperand how to do address mode matching.
277 OS << "0(" + regToString(MI->getOperand(OpNo)) + ')';
281 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, AsmVariant, ExtraCode, OS);
284 // Force static initialization.
285 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
286 RegisterAsmPrinter<WebAssemblyAsmPrinter> X(getTheWebAssemblyTarget32());
287 RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(getTheWebAssemblyTarget64());