contrib/llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCCodeEmitter.cpp

   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/WebAssemblyMCTargetDesc.h"
  16 #include "MCTargetDesc/WebAssemblyFixupKinds.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"