1 // WebAssemblyMCInstLower.cpp - Convert WebAssembly MachineInstr to an MCInst //
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 code to lower WebAssembly MachineInstrs to their
12 /// corresponding MCInst records.
14 //===----------------------------------------------------------------------===//
16 #include "WebAssemblyMCInstLower.h"
17 #include "WebAssemblyAsmPrinter.h"
18 #include "WebAssemblyMachineFunctionInfo.h"
19 #include "WebAssemblyRuntimeLibcallSignatures.h"
20 #include "WebAssemblyUtilities.h"
21 #include "llvm/CodeGen/AsmPrinter.h"
22 #include "llvm/CodeGen/MachineFunction.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/MC/MCAsmInfo.h"
25 #include "llvm/MC/MCContext.h"
26 #include "llvm/MC/MCExpr.h"
27 #include "llvm/MC/MCInst.h"
28 #include "llvm/MC/MCSymbolELF.h"
29 #include "llvm/MC/MCSymbolWasm.h"
30 #include "llvm/Support/ErrorHandling.h"
31 #include "llvm/Support/raw_ostream.h"
35 WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
36 const GlobalValue *Global = MO.getGlobal();
37 MCSymbol *Sym = Printer.getSymbol(Global);
38 if (isa<MCSymbolELF>(Sym))
41 MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
43 if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
44 const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
45 const TargetMachine &TM = MF.getTarget();
46 const Function &CurrentFunc = MF.getFunction();
48 SmallVector<wasm::ValType, 4> Returns;
49 SmallVector<wasm::ValType, 4> Params;
52 MF.getSubtarget<WebAssemblySubtarget>().hasAddr64() ?
56 SmallVector<MVT, 4> ResultMVTs;
57 ComputeLegalValueVTs(CurrentFunc, TM, FuncTy->getReturnType(), ResultMVTs);
58 // WebAssembly can't currently handle returning tuples.
59 if (ResultMVTs.size() <= 1)
60 for (MVT ResultMVT : ResultMVTs)
61 Returns.push_back(WebAssembly::toValType(ResultMVT));
63 Params.push_back(iPTR);
65 for (Type *Ty : FuncTy->params()) {
66 SmallVector<MVT, 4> ParamMVTs;
67 ComputeLegalValueVTs(CurrentFunc, TM, Ty, ParamMVTs);
68 for (MVT ParamMVT : ParamMVTs)
69 Params.push_back(WebAssembly::toValType(ParamMVT));
72 if (FuncTy->isVarArg())
73 Params.push_back(iPTR);
75 WasmSym->setReturns(std::move(Returns));
76 WasmSym->setParams(std::move(Params));
77 WasmSym->setIsFunction(true);
83 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
84 const MachineOperand &MO) const {
85 const char *Name = MO.getSymbolName();
86 MCSymbol *Sym = Printer.GetExternalSymbolSymbol(Name);
87 if (isa<MCSymbolELF>(Sym))
90 MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
91 const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
93 // __stack_pointer is a global variable; all other external symbols used by
94 // CodeGen are functions.
95 if (strcmp(Name, "__stack_pointer") == 0)
98 SmallVector<wasm::ValType, 4> Returns;
99 SmallVector<wasm::ValType, 4> Params;
100 GetSignature(Subtarget, Name, Returns, Params);
102 WasmSym->setReturns(std::move(Returns));
103 WasmSym->setParams(std::move(Params));
104 WasmSym->setIsFunction(true);
109 MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
112 MCSymbolRefExpr::VariantKind VK =
113 IsFunc ? MCSymbolRefExpr::VK_WebAssembly_FUNCTION
114 : MCSymbolRefExpr::VK_None;
116 const MCExpr *Expr = MCSymbolRefExpr::create(Sym, VK, Ctx);
120 report_fatal_error("Function addresses with offsets not supported");
122 MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(Offset, Ctx), Ctx);
125 return MCOperand::createExpr(Expr);
128 // Return the WebAssembly type associated with the given register class.
129 static wasm::ValType getType(const TargetRegisterClass *RC) {
130 if (RC == &WebAssembly::I32RegClass)
131 return wasm::ValType::I32;
132 if (RC == &WebAssembly::I64RegClass)
133 return wasm::ValType::I64;
134 if (RC == &WebAssembly::F32RegClass)
135 return wasm::ValType::F32;
136 if (RC == &WebAssembly::F64RegClass)
137 return wasm::ValType::F64;
138 llvm_unreachable("Unexpected register class");
141 void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
142 MCInst &OutMI) const {
143 OutMI.setOpcode(MI->getOpcode());
145 const MCInstrDesc &Desc = MI->getDesc();
146 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
147 const MachineOperand &MO = MI->getOperand(i);
150 switch (MO.getType()) {
153 llvm_unreachable("unknown operand type");
154 case MachineOperand::MO_MachineBasicBlock:
156 llvm_unreachable("MachineBasicBlock operand should have been rewritten");
157 case MachineOperand::MO_Register: {
158 // Ignore all implicit register operands.
161 const WebAssemblyFunctionInfo &MFI =
162 *MI->getParent()->getParent()->getInfo<WebAssemblyFunctionInfo>();
163 unsigned WAReg = MFI.getWAReg(MO.getReg());
164 MCOp = MCOperand::createReg(WAReg);
167 case MachineOperand::MO_Immediate:
168 if (i < Desc.NumOperands) {
169 const MCOperandInfo &Info = Desc.OpInfo[i];
170 if (Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) {
171 MCSymbol *Sym = Printer.createTempSymbol("typeindex");
172 if (!isa<MCSymbolELF>(Sym)) {
173 SmallVector<wasm::ValType, 4> Returns;
174 SmallVector<wasm::ValType, 4> Params;
176 const MachineRegisterInfo &MRI =
177 MI->getParent()->getParent()->getRegInfo();
178 for (const MachineOperand &MO : MI->defs())
179 Returns.push_back(getType(MRI.getRegClass(MO.getReg())));
180 for (const MachineOperand &MO : MI->explicit_uses())
182 Params.push_back(getType(MRI.getRegClass(MO.getReg())));
184 // call_indirect instructions have a callee operand at the end which
185 // doesn't count as a param.
186 if (WebAssembly::isCallIndirect(*MI))
189 MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
190 WasmSym->setReturns(std::move(Returns));
191 WasmSym->setParams(std::move(Params));
192 WasmSym->setIsFunction(true);
195 MCSymbolRefExpr::create(WasmSym,
196 MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX,
198 MCOp = MCOperand::createExpr(Expr);
203 MCOp = MCOperand::createImm(MO.getImm());
205 case MachineOperand::MO_FPImmediate: {
206 // TODO: MC converts all floating point immediate operands to double.
207 // This is fine for numeric values, but may cause NaNs to change bits.
208 const ConstantFP *Imm = MO.getFPImm();
209 if (Imm->getType()->isFloatTy())
210 MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToFloat());
211 else if (Imm->getType()->isDoubleTy())
212 MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToDouble());
214 llvm_unreachable("unknown floating point immediate type");
217 case MachineOperand::MO_GlobalAddress:
218 assert(MO.getTargetFlags() == 0 &&
219 "WebAssembly does not use target flags on GlobalAddresses");
220 MCOp = LowerSymbolOperand(GetGlobalAddressSymbol(MO), MO.getOffset(),
221 MO.getGlobal()->getValueType()->isFunctionTy());
223 case MachineOperand::MO_ExternalSymbol:
224 // The target flag indicates whether this is a symbol for a
225 // variable or a function.
226 assert((MO.getTargetFlags() & -2) == 0 &&
227 "WebAssembly uses only one target flag bit on ExternalSymbols");
228 MCOp = LowerSymbolOperand(GetExternalSymbolSymbol(MO), /*Offset=*/0,
229 MO.getTargetFlags() & 1);
233 OutMI.addOperand(MCOp);