LLVM  9.0.0svn
WebAssemblyMCInstLower.cpp
Go to the documentation of this file.
1 // WebAssemblyMCInstLower.cpp - Convert WebAssembly MachineInstr to an MCInst //
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 ///
9 /// \file
10 /// This file contains code to lower WebAssembly MachineInstrs to their
11 /// corresponding MCInst records.
12 ///
13 //===----------------------------------------------------------------------===//
14 
15 #include "WebAssemblyMCInstLower.h"
16 #include "WebAssemblyAsmPrinter.h"
19 #include "WebAssemblyUtilities.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCContext.h"
25 #include "llvm/MC/MCExpr.h"
26 #include "llvm/MC/MCInst.h"
27 #include "llvm/MC/MCSymbolWasm.h"
30 using namespace llvm;
31 
32 // Defines llvm::WebAssembly::getStackOpcode to convert register instructions to
33 // stack instructions
34 #define GET_INSTRMAP_INFO 1
35 #include "WebAssemblyGenInstrInfo.inc"
36 
37 // This disables the removal of registers when lowering into MC, as required
38 // by some current tests.
40  WasmKeepRegisters("wasm-keep-registers", cl::Hidden,
41  cl::desc("WebAssembly: output stack registers in"
42  " instruction output for test purposes only."),
43  cl::init(false));
44 
45 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI);
46 
47 MCSymbol *
48 WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
49  const GlobalValue *Global = MO.getGlobal();
50  auto *WasmSym = cast<MCSymbolWasm>(Printer.getSymbol(Global));
51 
52  if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
53  const MachineFunction &MF = *MO.getParent()->getParent()->getParent();
54  const TargetMachine &TM = MF.getTarget();
55  const Function &CurrentFunc = MF.getFunction();
56 
57  SmallVector<MVT, 1> ResultMVTs;
58  SmallVector<MVT, 4> ParamMVTs;
59  computeSignatureVTs(FuncTy, CurrentFunc, TM, ParamMVTs, ResultMVTs);
60 
61  auto Signature = signatureFromMVTs(ResultMVTs, ParamMVTs);
62  WasmSym->setSignature(Signature.get());
63  Printer.addSignature(std::move(Signature));
64  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
65  }
66 
67  return WasmSym;
68 }
69 
70 MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(
71  const MachineOperand &MO) const {
72  const char *Name = MO.getSymbolName();
73  auto *WasmSym = cast<MCSymbolWasm>(Printer.GetExternalSymbolSymbol(Name));
74  const WebAssemblySubtarget &Subtarget = Printer.getSubtarget();
75 
76  // Except for certain known symbols, all symbols used by CodeGen are
77  // functions. It's OK to hardcode knowledge of specific symbols here; this
78  // method is precisely there for fetching the signatures of known
79  // Clang-provided symbols.
80  if (strcmp(Name, "__stack_pointer") == 0 ||
81  strcmp(Name, "__memory_base") == 0 || strcmp(Name, "__table_base") == 0) {
82  bool Mutable = 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
87  Mutable});
88  return WasmSym;
89  }
90 
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
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 
123 MCOperand WebAssemblyMCInstLower::lowerSymbolOperand(const MachineOperand &MO,
124  MCSymbol *Sym) const {
126  unsigned TargetFlags = MO.getTargetFlags();
127 
128  switch (TargetFlags) {
130  break;
133  break;
136  break;
139  break;
140  default:
141  llvm_unreachable("Unknown target flag on GV operand");
142  }
143 
144  const MCExpr *Expr = MCSymbolRefExpr::create(Sym, Kind, Ctx);
145 
146  if (MO.getOffset() != 0) {
147  const auto *WasmSym = cast<MCSymbolWasm>(Sym);
148  if (TargetFlags == WebAssemblyII::MO_GOT)
149  report_fatal_error("GOT symbol references do not support offsets");
150  if (WasmSym->isFunction())
151  report_fatal_error("Function addresses with offsets not supported");
152  if (WasmSym->isGlobal())
153  report_fatal_error("Global indexes with offsets not supported");
154  if (WasmSym->isEvent())
155  report_fatal_error("Event indexes with offsets not supported");
156 
158  Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
159  }
160 
161  return MCOperand::createExpr(Expr);
162 }
163 
164 // Return the WebAssembly type associated with the given register class.
166  if (RC == &WebAssembly::I32RegClass)
167  return wasm::ValType::I32;
168  if (RC == &WebAssembly::I64RegClass)
169  return wasm::ValType::I64;
170  if (RC == &WebAssembly::F32RegClass)
171  return wasm::ValType::F32;
172  if (RC == &WebAssembly::F64RegClass)
173  return wasm::ValType::F64;
174  if (RC == &WebAssembly::V128RegClass)
175  return wasm::ValType::V128;
176  llvm_unreachable("Unexpected register class");
177 }
178 
180  MCInst &OutMI) const {
181  OutMI.setOpcode(MI->getOpcode());
182 
183  const MCInstrDesc &Desc = MI->getDesc();
184  for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {
185  const MachineOperand &MO = MI->getOperand(I);
186 
187  MCOperand MCOp;
188  switch (MO.getType()) {
189  default:
190  MI->print(errs());
191  llvm_unreachable("unknown operand type");
193  MI->print(errs());
194  llvm_unreachable("MachineBasicBlock operand should have been rewritten");
196  // Ignore all implicit register operands.
197  if (MO.isImplicit())
198  continue;
199  const WebAssemblyFunctionInfo &MFI =
201  unsigned WAReg = MFI.getWAReg(MO.getReg());
202  MCOp = MCOperand::createReg(WAReg);
203  break;
204  }
206  if (I < Desc.NumOperands) {
207  const MCOperandInfo &Info = Desc.OpInfo[I];
209  MCSymbol *Sym = Printer.createTempSymbol("typeindex");
210 
213 
214  const MachineRegisterInfo &MRI =
215  MI->getParent()->getParent()->getRegInfo();
216  for (const MachineOperand &MO : MI->defs())
217  Returns.push_back(getType(MRI.getRegClass(MO.getReg())));
218  for (const MachineOperand &MO : MI->explicit_uses())
219  if (MO.isReg())
220  Params.push_back(getType(MRI.getRegClass(MO.getReg())));
221 
222  // call_indirect instructions have a callee operand at the end which
223  // doesn't count as a param.
225  Params.pop_back();
226 
227  auto *WasmSym = cast<MCSymbolWasm>(Sym);
228  auto Signature = make_unique<wasm::WasmSignature>(std::move(Returns),
229  std::move(Params));
230  WasmSym->setSignature(Signature.get());
231  Printer.addSignature(std::move(Signature));
232  WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
233 
234  const MCExpr *Expr = MCSymbolRefExpr::create(
235  WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
236  MCOp = MCOperand::createExpr(Expr);
237  break;
238  }
239  }
240  MCOp = MCOperand::createImm(MO.getImm());
241  break;
243  // TODO: MC converts all floating point immediate operands to double.
244  // This is fine for numeric values, but may cause NaNs to change bits.
245  const ConstantFP *Imm = MO.getFPImm();
246  if (Imm->getType()->isFloatTy())
248  else if (Imm->getType()->isDoubleTy())
250  else
251  llvm_unreachable("unknown floating point immediate type");
252  break;
253  }
255  MCOp = lowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));
256  break;
258  // The target flag indicates whether this is a symbol for a
259  // variable or a function.
260  assert(MO.getTargetFlags() == 0 &&
261  "WebAssembly uses only symbol flags on ExternalSymbols");
262  MCOp = lowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));
263  break;
265  // This is currently used only for LSDA symbols (GCC_except_table),
266  // because global addresses or other external symbols are handled above.
267  assert(MO.getTargetFlags() == 0 &&
268  "WebAssembly does not use target flags on MCSymbol");
269  MCOp = lowerSymbolOperand(MO, MO.getMCSymbol());
270  break;
271  }
272 
273  OutMI.addOperand(MCOp);
274  }
275 
276  if (!WasmKeepRegisters)
277  removeRegisterOperands(MI, OutMI);
278 }
279 
280 static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI) {
281  // Remove all uses of stackified registers to bring the instruction format
282  // into its final stack form used thruout MC, and transition opcodes to
283  // their _S variant.
284  // We do this seperate from the above code that still may need these
285  // registers for e.g. call_indirect signatures.
286  // See comments in lib/Target/WebAssembly/WebAssemblyInstrFormats.td for
287  // details.
288  // TODO: the code above creates new registers which are then removed here.
289  // That code could be slightly simplified by not doing that, though maybe
290  // it is simpler conceptually to keep the code above in "register mode"
291  // until this transition point.
292  // FIXME: we are not processing inline assembly, which contains register
293  // operands, because it is used by later target generic code.
294  if (MI->isDebugInstr() || MI->isLabel() || MI->isInlineAsm())
295  return;
296 
297  // Transform to _S instruction.
298  auto RegOpcode = OutMI.getOpcode();
299  auto StackOpcode = WebAssembly::getStackOpcode(RegOpcode);
300  assert(StackOpcode != -1 && "Failed to stackify instruction");
301  OutMI.setOpcode(StackOpcode);
302 
303  // Remove register operands.
304  for (auto I = OutMI.getNumOperands(); I; --I) {
305  auto &MO = OutMI.getOperand(I - 1);
306  if (MO.isReg()) {
307  OutMI.erase(&MO);
308  }
309  }
310 }
unsigned getTargetFlags() const
raw_ostream & errs()
This returns a reference to a raw_ostream for standard error.
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
bool isLabel() const
Returns true if the MachineInstr represents a label.
Definition: MachineInstr.h:985
const TargetRegisterClass * getRegClass(unsigned Reg) const
Return the register class of the specified virtual register.
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:321
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:41
amdgpu Simplify well known AMD library false FunctionCallee Value const Twine & Name
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:136
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:163
unsigned getReg() const
getReg - Returns the register number.
bool isInlineAsm() const
This file declares the class to lower WebAssembly MachineInstrs to their corresponding MCInst records...
float convertToFloat() const
Definition: APFloat.h:1097
MachineBasicBlock reference.
void computeSignatureVTs(const FunctionType *Ty, const Function &F, const TargetMachine &TM, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results)
cl::opt< bool > WasmKeepRegisters("wasm-keep-registers", cl::Hidden, cl::desc("WebAssembly: output stack registers in" " instruction output for test purposes only."), cl::init(false))
std::unique_ptr< wasm::WasmSignature > signatureFromMVTs(const SmallVectorImpl< MVT > &Results, const SmallVectorImpl< MVT > &Params)
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:115
const ConstantFP * getFPImm() const
unsigned getNumOperands() const
Retuns the total number of operands.
Definition: MachineInstr.h:411
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:35
void erase(iterator I)
Definition: MCInst.h:189
Name of external global symbol.
static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI)
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:408
const char * getSymbolName() const
uint8_t OperandType
Information about the type of the operand.
Definition: MCInstrDesc.h:78
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
Definition: MachineInstr.h:405
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:244
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:459
Analysis containing CSE Info
Definition: CSEInfo.cpp:20
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:158
unsigned short NumOperands
Definition: MCInstrDesc.h:166
void getLibcallSignature(const WebAssemblySubtarget &Subtarget, RTLIB::Libcall LC, SmallVectorImpl< wasm::ValType > &Rets, SmallVectorImpl< wasm::ValType > &Params)
This file contains the declaration of the WebAssembly-specific utility functions. ...
bool isFloatTy() const
Return true if this is &#39;float&#39;, a 32-bit IEEE fp type.
Definition: Type.h:146
Address of a global value.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:427
unsigned const MachineRegisterInfo * MRI
This file provides signature information for runtime libcalls.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
const WebAssemblySubtarget & getSubtarget() const
This file contains the declarations for the subclasses of Constant, which represent the different fla...
const GlobalValue * getGlobal() const
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:263
double convertToDouble() const
Definition: APFloat.h:1096
iterator_range< mop_iterator > defs()
Returns a range over all explicit operands that are register definitions.
Definition: MachineInstr.h:480
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
unsigned getNumOperands() const
Definition: MCInst.h:181
void print(raw_ostream &OS, bool IsStandalone=true, bool SkipOpers=false, bool SkipDebugLoc=false, bool AddNewLine=true, const TargetInstrInfo *TII=nullptr) const
Print this MI to OS.
type signature immediate for call_indirect.
static wasm::ValType getType(const TargetRegisterClass *RC)
bool isDebugInstr() const
Definition: MachineInstr.h:998
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
iterator_range< mop_iterator > explicit_uses()
Definition: MachineInstr.h:498
void addSignature(std::unique_ptr< wasm::WasmSignature > &&Sig)
const APFloat & getValueAPF() const
Definition: Constants.h:302
void setOpcode(unsigned Op)
Definition: MCInst.h:170
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:440
MachineOperand class - Representation of each machine instruction operand.
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
const MCOperand & getOperand(unsigned i) const
Definition: MCInst.h:179
static MCOperand createFPImm(double Val)
Definition: MCInst.h:129
int64_t getImm() const
const Function & getFunction() const
Return the LLVM function that this machine code represents.
MCSymbol reference (for debug/eh info)
const MachineBasicBlock * getParent() const
Definition: MachineInstr.h:253
MachineRegisterInfo - Keep track of information for virtual and physical registers, including vreg register classes, use/def chains for registers, etc.
Representation of each machine instruction.
Definition: MachineInstr.h:63
This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information ...
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
int64_t getOffset() const
Return the offset from the symbol in this operand.
#define I(x, y, z)
Definition: MD5.cpp:58
This file declares WebAssembly-specific per-machine-function information.
Type * getValueType() const
Definition: GlobalValue.h:275
unsigned getWAReg(unsigned VReg) const
const LLVMTargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
bool isReg() const
isReg - Tests if this is a MO_Register operand.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
MCSymbol * getMCSymbol() const
Floating-point immediate operand.
void lower(const MachineInstr *MI, MCInst &OutMI) const
const MCOperandInfo * OpInfo
Definition: MCInstrDesc.h:174
Primary interface to the complete machine description for the target machine.
Definition: TargetMachine.h:65
IRTranslator LLVM IR MI
void addOperand(const MCOperand &Op)
Definition: MCInst.h:183
bool isCallIndirect(const MachineInstr &MI)
This holds information about one operand of a machine instruction, indicating the register class for ...
Definition: MCInstrDesc.h:66
unsigned getOpcode() const
Definition: MCInst.h:171
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:413
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:34
bool isDoubleTy() const
Return true if this is &#39;double&#39;, a 64-bit IEEE fp type.
Definition: Type.h:149
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
MCSymbol * createTempSymbol(const Twine &Name) const
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:122
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx)
Definition: MCExpr.cpp:163
bool isImplicit() const