1 // WebAssemblyMCInstLower.cpp - Convert WebAssembly MachineInstr to an MCInst //
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 ///
10 /// \file
11 /// This file contains code to lower WebAssembly MachineInstrs to their
12 /// corresponding MCInst records.
13 ///
14 //===----------------------------------------------------------------------===//
15
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/MCSymbolWasm.h"
29 #include "llvm/Support/ErrorHandling.h"
30 #include "llvm/Support/raw_ostream.h"
31 using namespace llvm;
32
33 // Defines llvm::WebAssembly::getStackOpcode to convert register instructions to
34 // stack instructions
35 #define GET_INSTRMAP_INFO 1
36 #include "WebAssemblyGenInstrInfo.inc"
37
38 // This disables the removal of registers when lowering into MC, as required
39 // by some current tests.
40 static cl::opt<bool>
41 WasmKeepRegisters("wasm-keep-registers", cl::Hidden,
42 cl::desc("WebAssembly: output stack registers in"
43 " instruction output for test purposes only."),
44 cl::init(false));
45
46 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI);
47
48 MCSymbol *
GetGlobalAddressSymbol(const MachineOperand & MO) const49 WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
50 const GlobalValue *Global = MO.getGlobal();
51 MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Printer.getSymbol(Global));
52
53 if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
54 const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
55 const TargetMachine &TM = MF.getTarget();
56 const Function &CurrentFunc = MF.getFunction();
57
58 SmallVector<MVT, 1> ResultMVTs;
59 SmallVector<MVT, 4> ParamMVTs;
60 ComputeSignatureVTs(FuncTy, CurrentFunc, TM, ParamMVTs, ResultMVTs);
61
62 auto Signature = SignatureFromMVTs(ResultMVTs, ParamMVTs);
63 WasmSym->setSignature(Signature.get());
64 Printer.addSignature(std::move(Signature));
65 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
66 }
67
68 return WasmSym;
69 }
70
GetExternalSymbolSymbol(const MachineOperand & MO) const71 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
72 const MachineOperand &MO) const {
73 const char *Name = MO.getSymbolName();
74 MCSymbolWasm *WasmSym =
75 cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
76 const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
77
78 // Except for the two exceptions (__stack_pointer and __cpp_exception), all
79 // other external symbols used by CodeGen are functions. It's OK to hardcode
80 // knowledge of specific symbols here; this method is precisely there for
81 // fetching the signatures of known Clang-provided symbols.
82 if (strcmp(Name, "__stack_pointer") == 0) {
83 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
84 WasmSym->setGlobalType(wasm::WasmGlobalType{
85 uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
86 : wasm::WASM_TYPE_I32),
87 true});
88 return WasmSym;
89 }
90
91 SmallVector<wasm::ValType, 4> Returns;
92 SmallVector<wasm::ValType, 4> Params;
93 if (strcmp(Name, "__cpp_exception") == 0) {
94 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_EVENT);
95 // We can't confirm its signature index for now because there can be
96 // imported exceptions. Set it to be 0 for now.
97 WasmSym->setEventType(
98 {wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION, /* SigIndex */ 0});
99 // We may have multiple C++ compilation units to be linked together, each of
100 // which defines the exception symbol. To resolve them, we declare them as
101 // weak.
102 WasmSym->setWeak(true);
103 WasmSym->setExternal(true);
104
105 // All C++ exceptions are assumed to have a single i32 (for wasm32) or i64
106 // (for wasm64) param type and void return type. The reaon is, all C++
107 // exception values are pointers, and to share the type section with
108 // functions, exceptions are assumed to have void return type.
109 Params.push_back(Subtarget.hasAddr64() ? wasm::ValType::I64
110 : wasm::ValType::I32);
111 } else { // Function symbols
112 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
113 GetLibcallSignature(Subtarget, Name, Returns, Params);
114 }
115 auto Signature =
116 make_unique<wasm::WasmSignature>(std::move(Returns), std::move(Params));
117 WasmSym->setSignature(Signature.get());
118 Printer.addSignature(std::move(Signature));
119
120 return WasmSym;
121 }
122
LowerSymbolOperand(MCSymbol * Sym,int64_t Offset,bool IsFunc,bool IsGlob,bool IsEvent) const123 MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
124 int64_t Offset,
125 bool IsFunc, bool IsGlob,
126 bool IsEvent) const {
127 MCSymbolRefExpr::VariantKind VK =
128 IsFunc ? MCSymbolRefExpr::VK_WebAssembly_FUNCTION
129 : IsGlob ? MCSymbolRefExpr::VK_WebAssembly_GLOBAL
130 : IsEvent ? MCSymbolRefExpr::VK_WebAssembly_EVENT
131 : MCSymbolRefExpr::VK_None;
132
133 const MCExpr *Expr = MCSymbolRefExpr::create(Sym, VK, Ctx);
134
135 if (Offset != 0) {
136 if (IsFunc)
137 report_fatal_error("Function addresses with offsets not supported");
138 if (IsGlob)
139 report_fatal_error("Global indexes with offsets not supported");
140 if (IsEvent)
141 report_fatal_error("Event indexes with offsets not supported");
142 Expr =
143 MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(Offset, Ctx), Ctx);
144 }
145
146 return MCOperand::createExpr(Expr);
147 }
148
149 // Return the WebAssembly type associated with the given register class.
getType(const TargetRegisterClass * RC)150 static wasm::ValType getType(const TargetRegisterClass *RC) {
151 if (RC == &WebAssembly::I32RegClass)
152 return wasm::ValType::I32;
153 if (RC == &WebAssembly::I64RegClass)
154 return wasm::ValType::I64;
155 if (RC == &WebAssembly::F32RegClass)
156 return wasm::ValType::F32;
157 if (RC == &WebAssembly::F64RegClass)
158 return wasm::ValType::F64;
159 if (RC == &WebAssembly::V128RegClass)
160 return wasm::ValType::V128;
161 llvm_unreachable("Unexpected register class");
162 }
163
Lower(const MachineInstr * MI,MCInst & OutMI) const164 void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
165 MCInst &OutMI) const {
166 OutMI.setOpcode(MI->getOpcode());
167
168 const MCInstrDesc &Desc = MI->getDesc();
169 for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
170 const MachineOperand &MO = MI->getOperand(i);
171
172 MCOperand MCOp;
173 switch (MO.getType()) {
174 default:
175 MI->print(errs());
176 llvm_unreachable("unknown operand type");
177 case MachineOperand::MO_MachineBasicBlock:
178 MI->print(errs());
179 llvm_unreachable("MachineBasicBlock operand should have been rewritten");
180 case MachineOperand::MO_Register: {
181 // Ignore all implicit register operands.
182 if (MO.isImplicit())
183 continue;
184 const WebAssemblyFunctionInfo &MFI =
185 *MI->getParent()->getParent()->getInfo<WebAssemblyFunctionInfo>();
186 unsigned WAReg = MFI.getWAReg(MO.getReg());
187 MCOp = MCOperand::createReg(WAReg);
188 break;
189 }
190 case MachineOperand::MO_Immediate:
191 if (i < Desc.NumOperands) {
192 const MCOperandInfo &Info = Desc.OpInfo[i];
193 if (Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) {
194 MCSymbol *Sym = Printer.createTempSymbol("typeindex");
195
196 SmallVector<wasm::ValType, 4> Returns;
197 SmallVector<wasm::ValType, 4> Params;
198
199 const MachineRegisterInfo &MRI =
200 MI->getParent()->getParent()->getRegInfo();
201 for (const MachineOperand &MO : MI->defs())
202 Returns.push_back(getType(MRI.getRegClass(MO.getReg())));
203 for (const MachineOperand &MO : MI->explicit_uses())
204 if (MO.isReg())
205 Params.push_back(getType(MRI.getRegClass(MO.getReg())));
206
207 // call_indirect instructions have a callee operand at the end which
208 // doesn't count as a param.
209 if (WebAssembly::isCallIndirect(*MI))
210 Params.pop_back();
211
212 MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
213 auto Signature = make_unique<wasm::WasmSignature>(std::move(Returns),
214 std::move(Params));
215 WasmSym->setSignature(Signature.get());
216 Printer.addSignature(std::move(Signature));
217 WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
218
219 const MCExpr *Expr = MCSymbolRefExpr::create(
220 WasmSym, MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX, Ctx);
221 MCOp = MCOperand::createExpr(Expr);
222 break;
223 }
224 }
225 MCOp = MCOperand::createImm(MO.getImm());
226 break;
227 case MachineOperand::MO_FPImmediate: {
228 // TODO: MC converts all floating point immediate operands to double.
229 // This is fine for numeric values, but may cause NaNs to change bits.
230 const ConstantFP *Imm = MO.getFPImm();
231 if (Imm->getType()->isFloatTy())
232 MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToFloat());
233 else if (Imm->getType()->isDoubleTy())
234 MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToDouble());
235 else
236 llvm_unreachable("unknown floating point immediate type");
237 break;
238 }
239 case MachineOperand::MO_GlobalAddress:
240 assert(MO.getTargetFlags() == WebAssemblyII::MO_NO_FLAG &&
241 "WebAssembly does not use target flags on GlobalAddresses");
242 MCOp = LowerSymbolOperand(GetGlobalAddressSymbol(MO), MO.getOffset(),
243 MO.getGlobal()->getValueType()->isFunctionTy(),
244 false, false);
245 break;
246 case MachineOperand::MO_ExternalSymbol:
247 // The target flag indicates whether this is a symbol for a
248 // variable or a function.
249 assert((MO.getTargetFlags() & ~WebAssemblyII::MO_SYMBOL_MASK) == 0 &&
250 "WebAssembly uses only symbol flags on ExternalSymbols");
251 MCOp = LowerSymbolOperand(
252 GetExternalSymbolSymbol(MO), /*Offset=*/0,
253 (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_FUNCTION) != 0,
254 (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_GLOBAL) != 0,
255 (MO.getTargetFlags() & WebAssemblyII::MO_SYMBOL_EVENT) != 0);
256 break;
257 case MachineOperand::MO_MCSymbol:
258 // This is currently used only for LSDA symbols (GCC_except_table),
259 // because global addresses or other external symbols are handled above.
260 assert(MO.getTargetFlags() == 0 &&
261 "WebAssembly does not use target flags on MCSymbol");
262 MCOp = LowerSymbolOperand(MO.getMCSymbol(), /*Offset=*/0, false, false,
263 false);
264 break;
265 }
266
267 OutMI.addOperand(MCOp);
268 }
269
270 if (!WasmKeepRegisters)
271 removeRegisterOperands(MI, OutMI);
272 }
273
removeRegisterOperands(const MachineInstr * MI,MCInst & OutMI)274 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI) {
275 // Remove all uses of stackified registers to bring the instruction format
276 // into its final stack form used thruout MC, and transition opcodes to
277 // their _S variant.
278 // We do this seperate from the above code that still may need these
279 // registers for e.g. call_indirect signatures.
280 // See comments in lib/Target/WebAssembly/WebAssemblyInstrFormats.td for
281 // details.
282 // TODO: the code above creates new registers which are then removed here.
283 // That code could be slightly simplified by not doing that, though maybe
284 // it is simpler conceptually to keep the code above in "register mode"
285 // until this transition point.
286 // FIXME: we are not processing inline assembly, which contains register
287 // operands, because it is used by later target generic code.
288 if (MI->isDebugInstr() || MI->isLabel() || MI->isInlineAsm())
289 return;
290
291 // Transform to _S instruction.
292 auto RegOpcode = OutMI.getOpcode();
293 auto StackOpcode = WebAssembly::getStackOpcode(RegOpcode);
294 assert(StackOpcode != -1 && "Failed to stackify instruction");
295 OutMI.setOpcode(StackOpcode);
296
297 // Remove register operands.
298 for (auto I = OutMI.getNumOperands(); I; --I) {
299 auto &MO = OutMI.getOperand(I - 1);
300 if (MO.isReg()) {
301 OutMI.erase(&MO);
302 }
303 }
304 }
305