WebAssemblyMCInstLower.cpp Source File (original) (raw)

39using namespace llvm;

45 cl::desc("WebAssembly: output stack registers in"

46 " instruction output for test purposes only."),

52WebAssemblyMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {

60 !WasmSym->getType()) {

64 Type *GlobalVT = Global->getValueType();

69 }

70 return WasmSym;

71 }

75 const TargetMachine &TM = MF.getTarget();

84 bool InvokeDetected = false;

85 auto *WasmSym = Printer.getMCSymbolForFunction(F, Signature, InvokeDetected);

86 WasmSym->setSignature(Signature);

88 return WasmSym;

89}

91MCSymbol *WebAssemblyMCInstLower::GetExternalSymbolSymbol(

93 return Printer.getOrCreateWasmSymbol(MO.getSymbolName());

94}

100

101 switch (TargetFlags) {

103 break;

106 break;

109 break;

112 break;

115 break;

118 break;

119 default:

121 }

122

124

126 const auto *WasmSym = static_cast<const MCSymbolWasm *>(Sym);

129 if (WasmSym->isFunction())

131 if (WasmSym->isGlobal())

133 if (WasmSym->isTag())

135 if (WasmSym->isTable())

137

140 }

141

143}

144

145MCOperand WebAssemblyMCInstLower::lowerTypeIndexOperand(

148 auto Signature = Ctx.createWasmSignature();

149 Signature->Returns = std::move(Returns);

150 Signature->Params = std::move(Params);

151 auto *Sym =

152 static_cast<MCSymbolWasm *>(Printer.createTempSymbol("typeindex"));

153 Sym->setSignature(Signature);

155 const MCExpr *Expr =

158}

159

161WebAssemblyMCInstLower::lowerEncodedFunctionSignature(const APInt &Sig) const {

162

166

167 int Idx = NumWords;

168 auto GetWord = [&Idx, &Sig]() {

169 Idx--;

171 };

172

173

174

175

176

177 int NReturns = GetWord() ^ 0x7ffffff;

178 for (int I = 0; I < NReturns; I++) {

180 }

181 int NParams = GetWord();

182 for (int I = 0; I < NParams; I++) {

184 }

185 return lowerTypeIndexOperand(std::move(Returns), std::move(Params));

186}

187

190 const Function &F = MI->getMF()->getFunction();

192 Type *RetTy = F.getReturnType();

196}

197

199 MCInst &OutMI) const {

201

203 unsigned NumVariadicDefs = MI->getNumExplicitDefs() - Desc.getNumDefs();

205 const auto &TLI =

210

211 for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) {

213

216 default:

221 llvm_unreachable("MachineBasicBlock operand should have been rewritten");

223

225 continue;

230 break;

231 }

233

234

235

236 unsigned DescIndex = I - NumVariadicDefs;

237 assert(DescIndex < Desc.NumOperands && "unexpected CImmediate operand");

238 auto Operands = Desc.operands();

241 "unexpected CImmediate operand");

242 (void)Info;

243 MCOp = lowerEncodedFunctionSignature(MO.getCImm()->getValue());

244 break;

245 }

247 unsigned DescIndex = I - NumVariadicDefs;

248 if (DescIndex < Desc.NumOperands) {

249 auto Operands = Desc.operands();

251

252

253

255

258

260 MI->getParent()->getParent()->getRegInfo();

263 MRI.getRegClass(MO.getReg())->getID()));

267 MRI.getRegClass(MO.getReg())->getID()));

268

269

270

273

274

275

276 if (MI->getOpcode() == WebAssembly::RET_CALL_INDIRECT)

278

279 MCOp = lowerTypeIndexOperand(std::move(Returns), std::move(Params));

280 break;

281 }

283

288

289

290

291

292

293

294

295

296

297

298

301 } else

303 MCOp = lowerTypeIndexOperand(std::move(Returns),

305 break;

306 }

307 }

308 }

310 break;

311 }

315 Imm->getValueAPF().bitcastToAPInt().getZExtValue();

316 if (Imm->getType()->isFloatTy())

318 else if (Imm->getType()->isDoubleTy())

320 else

322 break;

323 }

325 MCOp = lowerSymbolOperand(MO, GetGlobalAddressSymbol(MO));

326 break;

328 MCOp = lowerSymbolOperand(MO, GetExternalSymbolSymbol(MO));

329 break;

332 "WebAssembly does not use target flags on MCSymbol");

333 MCOp = lowerSymbolOperand(MO, MO.getMCSymbol());

334 break;

335 }

336

338 }

339

342 else if (Desc.variadicOpsAreDefs())

344}

345

347

348

349

350

351

352

353

354

355

356

357

358

359

360 if (MI->isDebugInstr() || MI->isLabel() || MI->isInlineAsm())

361 return;

362

363

364 auto RegOpcode = OutMI.getOpcode();

366 assert(StackOpcode != -1 && "Failed to stackify instruction");

368

369

372 if (MO.isReg()) {

373 OutMI.erase(&MO);

374 }

375 }

376}

unsigned const MachineRegisterInfo * MRI

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

This file implements a class to represent arbitrary precision integral constant values and operations...

This file contains the declarations for the subclasses of Constant, which represent the different fla...

dxil pretty DXIL Metadata Pretty Printer

This file defines the SmallVector class.

cl::opt< bool > WasmKeepRegisters

This file contains the declaration of the WebAssemblyMCAsmInfo class.

static void removeRegisterOperands(const MachineInstr *MI, MCInst &OutMI)

Definition WebAssemblyMCInstLower.cpp:346

static 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))

static void getFunctionReturns(const MachineInstr *MI, SmallVectorImpl< wasm::ValType > &Returns)

Definition WebAssemblyMCInstLower.cpp:188

This file declares the class to lower WebAssembly MachineInstrs to their corresponding MCInst records...

This file provides WebAssembly-specific target descriptions.

This file contains the declaration of the WebAssembly-specific type parsing utility functions.

This file declares WebAssembly-specific per-machine-function information.

This file registers the WebAssembly target.

This file contains the declaration of the WebAssembly-specific type parsing utility functions.

This file contains the declaration of the WebAssembly-specific utility functions.

Class for arbitrary precision integers.

LLVM_ABI uint64_t extractBitsAsZExtValue(unsigned numBits, unsigned bitPosition) const

unsigned getNumWords() const

Get the number of words.

ConstantFP - Floating Point Values [float, double].

const APInt & getValue() const

Return the constant as an APInt value reference.

static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx, SMLoc Loc=SMLoc())

static LLVM_ABI const MCConstantExpr * create(int64_t Value, MCContext &Ctx, bool PrintInHex=false, unsigned SizeInBytes=0)

Instances of this class represent a single low-level machine instruction.

unsigned getNumOperands() const

unsigned getOpcode() const

iterator insert(iterator I, const MCOperand &Op)

void addOperand(const MCOperand Op)

void setOpcode(unsigned Op)

const MCOperand & getOperand(unsigned i) const

Describe properties that are true of each instruction in the target description file.

This holds information about one operand of a machine instruction, indicating the register class for ...

Instances of this class represent operands of the MCInst class.

static MCOperand createExpr(const MCExpr *Val)

static MCOperand createSFPImm(uint32_t Val)

static MCOperand createReg(MCRegister Reg)

static MCOperand createImm(int64_t Val)

static MCOperand createDFPImm(uint64_t Val)

static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx, SMLoc Loc=SMLoc())

MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

const DataLayout & getDataLayout() const

Return the DataLayout attached to the Module associated to this MF.

Function & getFunction()

Return the LLVM function that this machine code represents.

const TargetMachine & getTarget() const

getTarget - Return the target machine this machine code is compiled with

Representation of each machine instruction.

const MachineBasicBlock * getParent() const

MachineOperand class - Representation of each machine instruction operand.

const GlobalValue * getGlobal() const

const ConstantInt * getCImm() const

bool isReg() const

isReg - Tests if this is a MO_Register operand.

MachineInstr * getParent()

getParent - Return the instruction that this operand belongs to.

unsigned getTargetFlags() const

MachineOperandType getType() const

getType - Returns the MachineOperandType for this operand.

const char * getSymbolName() const

getReg - Returns the register number.

const ConstantFP * getFPImm() const

MCSymbol * getMCSymbol() const

@ MO_Immediate

Immediate operand.

@ MO_MCSymbol

MCSymbol reference (for debug/eh info)

@ MO_GlobalAddress

Address of a global value.

@ MO_CImmediate

Immediate >64bit operand.

@ MO_MachineBasicBlock

MachineBasicBlock reference.

@ MO_Register

@ MO_ExternalSymbol

Name of external global symbol.

@ MO_FPImmediate

Floating-point immediate operand.

int64_t getOffset() const

Return the offset from the symbol in this operand.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

Primary interface to the complete machine description for the target machine.

The instances of the Type class are immutable: once they are created, they are never changed.

This class is derived from MachineFunctionInfo and contains private WebAssembly-specific information ...

unsigned getWAReg(Register VReg) const

void lower(const MachineInstr *MI, MCInst &OutMI) const

Definition WebAssemblyMCInstLower.cpp:198

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

bool isCallIndirect(unsigned Opc)

wasm::ValType regClassToValType(unsigned RC)

void wasmSymbolSetType(MCSymbolWasm *Sym, const Type *GlobalVT, ArrayRef< MVT > VTs)

Sets a Wasm Symbol Type.

BlockType

Used as immediate MachineOperands for block signatures.

@ OPERAND_TYPEINDEX

type signature immediate for call_indirect.

@ OPERAND_SIGNATURE

signature immediate for block/loop.

int getStackOpcode(unsigned short Opcode)

bool isWasmVarAddressSpace(unsigned AS)

initializer< Ty > init(const Ty &Val)

@ WASM_SYMBOL_TYPE_FUNCTION

This is an optimization pass for GlobalISel generic memory operations.

void computeSignatureVTs(const FunctionType *Ty, const Function *TargetFunc, const Function &ContextFunc, const TargetMachine &TM, SmallVectorImpl< MVT > &Params, SmallVectorImpl< MVT > &Results)

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

LLVM_ABI raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

@ Global

Append to llvm.global_dtors.

void valTypesFromMVTs(ArrayRef< MVT > In, SmallVectorImpl< wasm::ValType > &Out)

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

wasm::WasmSignature * signatureFromMVTs(MCContext &Ctx, const SmallVectorImpl< MVT > &Results, const SmallVectorImpl< MVT > &Params)

void computeLegalValueVTs(const WebAssemblyTargetLowering &TLI, LLVMContext &Ctx, const DataLayout &DL, Type *Ty, SmallVectorImpl< MVT > &ValueVTs)