1 //=- WebAssemblyMCCodeEmitter.cpp - Convert WebAssembly code to machine code -// 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 /// \brief This file implements the WebAssemblyMCCodeEmitter class. 12 /// 13 //===----------------------------------------------------------------------===// 14 15 #include "MCTargetDesc/WebAssemblyFixupKinds.h" 16 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" 17 #include "llvm/ADT/STLExtras.h" 18 #include "llvm/ADT/Statistic.h" 19 #include "llvm/MC/MCCodeEmitter.h" 20 #include "llvm/MC/MCFixup.h" 21 #include "llvm/MC/MCInst.h" 22 #include "llvm/MC/MCInstrInfo.h" 23 #include "llvm/MC/MCRegisterInfo.h" 24 #include "llvm/MC/MCSubtargetInfo.h" 25 #include "llvm/MC/MCSymbol.h" 26 #include "llvm/Support/EndianStream.h" 27 #include "llvm/Support/LEB128.h" 28 #include "llvm/Support/raw_ostream.h" 29 using namespace llvm; 30 31 #define DEBUG_TYPE "mccodeemitter" 32 33 STATISTIC(MCNumEmitted, "Number of MC instructions emitted."); 34 STATISTIC(MCNumFixups, "Number of MC fixups created."); 35 36 namespace { 37 class WebAssemblyMCCodeEmitter final : public MCCodeEmitter { 38 const MCInstrInfo &MCII; 39 MCContext &Ctx; 40 41 // Implementation generated by tablegen. 42 uint64_t getBinaryCodeForInstr(const MCInst &MI, 43 SmallVectorImpl<MCFixup> &Fixups, 44 const MCSubtargetInfo &STI) const; 45 46 void encodeInstruction(const MCInst &MI, raw_ostream &OS, 47 SmallVectorImpl<MCFixup> &Fixups, 48 const MCSubtargetInfo &STI) const override; 49 50 public: 51 WebAssemblyMCCodeEmitter(const MCInstrInfo &mcii, MCContext &ctx) 52 : MCII(mcii), Ctx(ctx) {} 53 }; 54 } // end anonymous namespace 55 56 MCCodeEmitter *llvm::createWebAssemblyMCCodeEmitter(const MCInstrInfo &MCII, 57 MCContext &Ctx) { 58 return new WebAssemblyMCCodeEmitter(MCII, Ctx); 59 } 60 61 void WebAssemblyMCCodeEmitter::encodeInstruction( 62 const MCInst &MI, raw_ostream &OS, SmallVectorImpl<MCFixup> &Fixups, 63 const MCSubtargetInfo &STI) const { 64 uint64_t Start = OS.tell(); 65 66 uint64_t Binary = getBinaryCodeForInstr(MI, Fixups, STI); 67 assert(Binary < UINT8_MAX && "Multi-byte opcodes not supported yet"); 68 OS << uint8_t(Binary); 69 70 // For br_table instructions, encode the size of the table. In the MCInst, 71 // there's an index operand, one operand for each table entry, and the 72 // default operand. 73 if (MI.getOpcode() == WebAssembly::BR_TABLE_I32 || 74 MI.getOpcode() == WebAssembly::BR_TABLE_I64) 75 encodeULEB128(MI.getNumOperands() - 2, OS); 76 77 const MCInstrDesc &Desc = MCII.get(MI.getOpcode()); 78 for (unsigned i = 0, e = MI.getNumOperands(); i < e; ++i) { 79 const MCOperand &MO = MI.getOperand(i); 80 if (MO.isReg()) { 81 /* nothing to encode */ 82 } else if (MO.isImm()) { 83 if (i < Desc.getNumOperands()) { 84 assert(Desc.TSFlags == 0 && 85 "WebAssembly non-variable_ops don't use TSFlags"); 86 const MCOperandInfo &Info = Desc.OpInfo[i]; 87 if (Info.OperandType == WebAssembly::OPERAND_I32IMM) { 88 encodeSLEB128(int32_t(MO.getImm()), OS); 89 } else if (Info.OperandType == WebAssembly::OPERAND_I64IMM) { 90 encodeSLEB128(int64_t(MO.getImm()), OS); 91 } else if (Info.OperandType == WebAssembly::OPERAND_GLOBAL) { 92 Fixups.push_back(MCFixup::create( 93 OS.tell() - Start, MCConstantExpr::create(MO.getImm(), Ctx), 94 MCFixupKind(WebAssembly::fixup_code_global_index), MI.getLoc())); 95 ++MCNumFixups; 96 encodeULEB128(uint64_t(MO.getImm()), OS); 97 } else if (Info.OperandType == WebAssembly::OPERAND_SIGNATURE) { 98 encodeSLEB128(int64_t(MO.getImm()), OS); 99 } else { 100 encodeULEB128(uint64_t(MO.getImm()), OS); 101 } 102 } else { 103 assert(Desc.TSFlags == (WebAssemblyII::VariableOpIsImmediate | 104 WebAssemblyII::VariableOpImmediateIsLabel)); 105 encodeULEB128(uint64_t(MO.getImm()), OS); 106 } 107 } else if (MO.isFPImm()) { 108 assert(i < Desc.getNumOperands() && 109 "Unexpected floating-point immediate as a non-fixed operand"); 110 assert(Desc.TSFlags == 0 && 111 "WebAssembly variable_ops floating point ops don't use TSFlags"); 112 const MCOperandInfo &Info = Desc.OpInfo[i]; 113 if (Info.OperandType == WebAssembly::OPERAND_F32IMM) { 114 // TODO: MC converts all floating point immediate operands to double. 115 // This is fine for numeric values, but may cause NaNs to change bits. 116 float f = float(MO.getFPImm()); 117 support::endian::Writer<support::little>(OS).write<float>(f); 118 } else { 119 assert(Info.OperandType == WebAssembly::OPERAND_F64IMM); 120 double d = MO.getFPImm(); 121 support::endian::Writer<support::little>(OS).write<double>(d); 122 } 123 } else if (MO.isExpr()) { 124 const MCOperandInfo &Info = Desc.OpInfo[i]; 125 llvm::MCFixupKind FixupKind; 126 size_t PaddedSize; 127 if (Info.OperandType == WebAssembly::OPERAND_I32IMM) { 128 FixupKind = MCFixupKind(WebAssembly::fixup_code_sleb128_i32); 129 PaddedSize = 5; 130 } else if (Info.OperandType == WebAssembly::OPERAND_I64IMM) { 131 FixupKind = MCFixupKind(WebAssembly::fixup_code_sleb128_i64); 132 PaddedSize = 10; 133 } else if (Info.OperandType == WebAssembly::OPERAND_FUNCTION32 || 134 Info.OperandType == WebAssembly::OPERAND_OFFSET32 || 135 Info.OperandType == WebAssembly::OPERAND_TYPEINDEX) { 136 FixupKind = MCFixupKind(WebAssembly::fixup_code_uleb128_i32); 137 PaddedSize = 5; 138 } else { 139 llvm_unreachable("unexpected symbolic operand kind"); 140 } 141 Fixups.push_back(MCFixup::create( 142 OS.tell() - Start, MO.getExpr(), 143 FixupKind, MI.getLoc())); 144 ++MCNumFixups; 145 encodeULEB128(0, OS, PaddedSize - 1); 146 } else { 147 llvm_unreachable("unexpected operand kind"); 148 } 149 } 150 151 ++MCNumEmitted; // Keep track of the # of mi's emitted. 152 } 153 154 #include "WebAssemblyGenMCCodeEmitter.inc" 155