WebAssemblyMCInstLower.cpp revision 341825 
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
33MCSymbol *
34WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
35  const GlobalValue *Global = MO.getGlobal();
36  MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Printer.getSymbol(Global));
37
38  if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
39    const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
40    const TargetMachine &TM = MF.getTarget();
41    const Function &CurrentFunc = MF.getFunction();
42
43    SmallVector<wasm::ValType, 4> Returns;
44    SmallVector<wasm::ValType, 4> Params;
45
46    wasm::ValType iPTR =
47        MF.getSubtarget<WebAssemblySubtarget>().hasAddr64() ?
48        wasm::ValType::I64 :
49        wasm::ValType::I32;
50
51    SmallVector<MVT, 4> ResultMVTs;
52    ComputeLegalValueVTs(CurrentFunc, TM, FuncTy->getReturnType(), ResultMVTs);
53    // WebAssembly can't currently handle returning tuples.
54    if (ResultMVTs.size() <= 1)
55      for (MVT ResultMVT : ResultMVTs)
56        Returns.push_back(WebAssembly::toValType(ResultMVT));
57    else
58      Params.push_back(iPTR);
59
60    for (Type *Ty : FuncTy->params()) {
61      SmallVector<MVT, 4> ParamMVTs;
62      ComputeLegalValueVTs(CurrentFunc, TM, Ty, ParamMVTs);
63      for (MVT ParamMVT : ParamMVTs)
64        Params.push_back(WebAssembly::toValType(ParamMVT));
65    }
66
67    if (FuncTy->isVarArg())
68      Params.push_back(iPTR);
69
70    WasmSym->setReturns(std::move(Returns));
71    WasmSym->setParams(std::move(Params));
72    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
73  }
74
75  return WasmSym;
76}
77
78MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
79    const MachineOperand &MO) const {
80  const char *Name = MO.getSymbolName();
81  MCSymbolWasm *WasmSym =
82      cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
83  const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
84
85  // __stack_pointer is a global variable; all other external symbols used by
86  // CodeGen are functions.  It's OK to hardcode knowledge of specific symbols
87  // here; this method is precisely there for fetching the signatures of known
88  // Clang-provided symbols.
89  if (strcmp(Name, "__stack_pointer") == 0) {
90    WasmSym->setType(wasm::WASM_SYMBOL_TYPE_GLOBAL);
91    WasmSym->setGlobalType(wasm::WasmGlobalType{
92        uint8_t(Subtarget.hasAddr64() ? wasm::WASM_TYPE_I64
93                                      : wasm::WASM_TYPE_I32),
94        true});
95    return WasmSym;
96  }
97
98  SmallVector<wasm::ValType, 4> Returns;
99  SmallVector<wasm::ValType, 4> Params;
100  GetSignature(Subtarget, Name, Returns, Params);
101
102  WasmSym->setReturns(std::move(Returns));
103  WasmSym->setParams(std::move(Params));
104  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
105
106  return WasmSym;
107}
108
109MCOperand WebAssemblyMCInstLower::LowerSymbolOperand(MCSymbol *Sym,
110                                                     int64_t Offset,
111                                                     bool IsFunc) const {
112  MCSymbolRefExpr::VariantKind VK =
113      IsFunc ? MCSymbolRefExpr::VK_WebAssembly_FUNCTION
114             : MCSymbolRefExpr::VK_None;
115
116  const MCExpr *Expr = MCSymbolRefExpr::create(Sym, VK, Ctx);
117
118  if (Offset != 0) {
119    if (IsFunc)
120      report_fatal_error("Function addresses with offsets not supported");
121    Expr =
122        MCBinaryExpr::createAdd(Expr, MCConstantExpr::create(Offset, Ctx), Ctx);
123  }
124
125  return MCOperand::createExpr(Expr);
126}
127
128// Return the WebAssembly type associated with the given register class.
129static 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");
139}
140
141void WebAssemblyMCInstLower::Lower(const MachineInstr *MI,
142                                   MCInst &OutMI) const {
143  OutMI.setOpcode(MI->getOpcode());
144
145  const MCInstrDesc &Desc = MI->getDesc();
146  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
147    const MachineOperand &MO = MI->getOperand(i);
148
149    MCOperand MCOp;
150    switch (MO.getType()) {
151    default:
152      MI->print(errs());
153      llvm_unreachable("unknown operand type");
154    case MachineOperand::MO_MachineBasicBlock:
155      MI->print(errs());
156      llvm_unreachable("MachineBasicBlock operand should have been rewritten");
157    case MachineOperand::MO_Register: {
158      // Ignore all implicit register operands.
159      if (MO.isImplicit())
160        continue;
161      const WebAssemblyFunctionInfo &MFI =
162          *MI->getParent()->getParent()->getInfo<WebAssemblyFunctionInfo>();
163      unsigned WAReg = MFI.getWAReg(MO.getReg());
164      MCOp = MCOperand::createReg(WAReg);
165      break;
166    }
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
173          SmallVector<wasm::ValType, 4> Returns;
174          SmallVector<wasm::ValType, 4> Params;
175
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())
181            if (MO.isReg())
182              Params.push_back(getType(MRI.getRegClass(MO.getReg())));
183
184          // call_indirect instructions have a callee operand at the end which
185          // doesn't count as a param.
186          if (WebAssembly::isCallIndirect(*MI))
187            Params.pop_back();
188
189          MCSymbolWasm *WasmSym = cast<MCSymbolWasm>(Sym);
190          WasmSym->setReturns(std::move(Returns));
191          WasmSym->setParams(std::move(Params));
192          WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
193
194          const MCExpr *Expr = MCSymbolRefExpr::create(
195              WasmSym, MCSymbolRefExpr::VK_WebAssembly_TYPEINDEX, Ctx);
196          MCOp = MCOperand::createExpr(Expr);
197          break;
198        }
199      }
200      MCOp = MCOperand::createImm(MO.getImm());
201      break;
202    case MachineOperand::MO_FPImmediate: {
203      // TODO: MC converts all floating point immediate operands to double.
204      // This is fine for numeric values, but may cause NaNs to change bits.
205      const ConstantFP *Imm = MO.getFPImm();
206      if (Imm->getType()->isFloatTy())
207        MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToFloat());
208      else if (Imm->getType()->isDoubleTy())
209        MCOp = MCOperand::createFPImm(Imm->getValueAPF().convertToDouble());
210      else
211        llvm_unreachable("unknown floating point immediate type");
212      break;
213    }
214    case MachineOperand::MO_GlobalAddress:
215      assert(MO.getTargetFlags() == 0 &&
216             "WebAssembly does not use target flags on GlobalAddresses");
217      MCOp = LowerSymbolOperand(GetGlobalAddressSymbol(MO), MO.getOffset(),
218                                MO.getGlobal()->getValueType()->isFunctionTy());
219      break;
220    case MachineOperand::MO_ExternalSymbol:
221      // The target flag indicates whether this is a symbol for a
222      // variable or a function.
223      assert((MO.getTargetFlags() & -2) == 0 &&
224             "WebAssembly uses only one target flag bit on ExternalSymbols");
225      MCOp = LowerSymbolOperand(GetExternalSymbolSymbol(MO), /*Offset=*/0,
226                                MO.getTargetFlags() & 1);
227      break;
228    }
229
230    OutMI.addOperand(MCOp);
231  }
232}
233