WebAssemblyMCInstLower.cpp revision 344779 
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"
31using 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.
40static 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
46static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI);
47
48MCSymbol *
49WebAssemblyMCInstLower::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
71MCSymbol *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
123MCOperand 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.
150static 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
164void 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
274static 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