contrib/llvm/lib/Target/WebAssembly/InstPrinter/WebAssemblyInstPrinter.cpp

   1 //=- WebAssemblyInstPrinter.cpp - WebAssembly assembly instruction printing -=//
   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 Print MCInst instructions to wasm format.
  12 ///
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "InstPrinter/WebAssemblyInstPrinter.h"
  16 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
  17 #include "WebAssembly.h"
  18 #include "WebAssemblyMachineFunctionInfo.h"
  19 #include "llvm/ADT/SmallSet.h"
  20 #include "llvm/ADT/StringExtras.h"
  21 #include "llvm/MC/MCExpr.h"
  22 #include "llvm/MC/MCInst.h"
  23 #include "llvm/MC/MCInstrInfo.h"
  24 #include "llvm/MC/MCSubtargetInfo.h"
  25 #include "llvm/MC/MCSymbol.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/FormattedStream.h"
  28 #include "llvm/Target/TargetRegisterInfo.h"
  29 using namespace llvm;
  30
  31 #define DEBUG_TYPE "asm-printer"
  32
  33 #include "WebAssemblyGenAsmWriter.inc"
  34
  35 WebAssemblyInstPrinter::WebAssemblyInstPrinter(const MCAsmInfo &MAI,
  36                                                const MCInstrInfo &MII,
  37                                                const MCRegisterInfo &MRI)
  38     : MCInstPrinter(MAI, MII, MRI), ControlFlowCounter(0) {}
  39
  40 void WebAssemblyInstPrinter::printRegName(raw_ostream &OS,
  41                                           unsigned RegNo) const {
  42   assert(RegNo != WebAssemblyFunctionInfo::UnusedReg);
  43   // Note that there's an implicit get_local/set_local here!
  44   OS << "$" << RegNo;
  45 }
  46
  47 void WebAssemblyInstPrinter::printInst(const MCInst *MI, raw_ostream &OS,
  48                                        StringRef Annot,
  49                                        const MCSubtargetInfo & /*STI*/) {
  50   // Print the instruction (this uses the AsmStrings from the .td files).
  51   printInstruction(MI, OS);
  52
  53   // Print any additional variadic operands.
  54   const MCInstrDesc &Desc = MII.get(MI->getOpcode());
  55   if (Desc.isVariadic())
  56     for (auto i = Desc.getNumOperands(), e = MI->getNumOperands(); i < e; ++i) {
  57       if (i != 0)
  58         OS << ", ";
  59       printOperand(MI, i, OS);
  60     }
  61
  62   // Print any added annotation.
  63   printAnnotation(OS, Annot);
  64
  65   if (CommentStream) {
  66     // Observe any effects on the control flow stack, for use in annotating
  67     // control flow label references.
  68     switch (MI->getOpcode()) {
  69     default:
  70       break;
  71     case WebAssembly::LOOP: {
  72       // Grab the TopLabel value first so that labels print in numeric order.
  73       uint64_t TopLabel = ControlFlowCounter++;
  74       ControlFlowStack.push_back(std::make_pair(ControlFlowCounter++, false));
  75       printAnnotation(OS, "label" + utostr(TopLabel) + ':');
  76       ControlFlowStack.push_back(std::make_pair(TopLabel, true));
  77       break;
  78     }
  79     case WebAssembly::BLOCK:
  80       ControlFlowStack.push_back(std::make_pair(ControlFlowCounter++, false));
  81       break;
  82     case WebAssembly::END_LOOP:
  83       ControlFlowStack.pop_back();
  84       printAnnotation(
  85           OS, "label" + utostr(ControlFlowStack.pop_back_val().first) + ':');
  86       break;
  87     case WebAssembly::END_BLOCK:
  88       printAnnotation(
  89           OS, "label" + utostr(ControlFlowStack.pop_back_val().first) + ':');
  90       break;
  91     }
  92
  93     // Annotate any control flow label references.
  94     unsigned NumFixedOperands = Desc.NumOperands;
  95     SmallSet<uint64_t, 8> Printed;
  96     for (unsigned i = 0, e = MI->getNumOperands(); i < e; ++i) {
  97       const MCOperandInfo &Info = Desc.OpInfo[i];
  98       if (!(i < NumFixedOperands
  99                 ? (Info.OperandType == WebAssembly::OPERAND_BASIC_BLOCK)
 100                 : (Desc.TSFlags & WebAssemblyII::VariableOpImmediateIsLabel)))
 101         continue;
 102       uint64_t Depth = MI->getOperand(i).getImm();
 103       if (!Printed.insert(Depth).second)
 104         continue;
 105       const auto &Pair = ControlFlowStack.rbegin()[Depth];
 106       printAnnotation(OS, utostr(Depth) + ": " + (Pair.second ? "up" : "down") +
 107                               " to label" + utostr(Pair.first));
 108     }
 109   }
 110 }
 111
 112 static std::string toString(const APFloat &FP) {
 113   static const size_t BufBytes = 128;
 114   char buf[BufBytes];
 115   if (FP.isNaN())
 116     assert((FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) ||
 117             FP.bitwiseIsEqual(
 118                 APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) &&
 119            "convertToHexString handles neither SNaN nor NaN payloads");
 120   // Use C99's hexadecimal floating-point representation.
 121   auto Written = FP.convertToHexString(
 122       buf, /*hexDigits=*/0, /*upperCase=*/false, APFloat::rmNearestTiesToEven);
 123   (void)Written;
 124   assert(Written != 0);
 125   assert(Written < BufBytes);
 126   return buf;
 127 }
 128
 129 void WebAssemblyInstPrinter::printOperand(const MCInst *MI, unsigned OpNo,
 130                                           raw_ostream &O) {
 131   const MCOperand &Op = MI->getOperand(OpNo);
 132   if (Op.isReg()) {
 133     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
 134             MII.get(MI->getOpcode()).TSFlags == 0) &&
 135            "WebAssembly variable_ops register ops don't use TSFlags");
 136     unsigned WAReg = Op.getReg();
 137     if (int(WAReg) >= 0)
 138       printRegName(O, WAReg);
 139     else if (OpNo >= MII.get(MI->getOpcode()).getNumDefs())
 140       O << "$pop" << (WAReg & INT32_MAX);
 141     else if (WAReg != WebAssemblyFunctionInfo::UnusedReg)
 142       O << "$push" << (WAReg & INT32_MAX);
 143     else
 144       O << "$discard";
 145     // Add a '=' suffix if this is a def.
 146     if (OpNo < MII.get(MI->getOpcode()).getNumDefs())
 147       O << '=';
 148   } else if (Op.isImm()) {
 149     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
 150             (MII.get(MI->getOpcode()).TSFlags &
 151              WebAssemblyII::VariableOpIsImmediate)) &&
 152            "WebAssemblyII::VariableOpIsImmediate should be set for "
 153            "variable_ops immediate ops");
 154     // TODO: (MII.get(MI->getOpcode()).TSFlags &
 155     //        WebAssemblyII::VariableOpImmediateIsLabel)
 156     // can tell us whether this is an immediate referencing a label in the
 157     // control flow stack, and it may be nice to pretty-print.
 158     O << Op.getImm();
 159   } else if (Op.isFPImm()) {
 160     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
 161             MII.get(MI->getOpcode()).TSFlags == 0) &&
 162            "WebAssembly variable_ops floating point ops don't use TSFlags");
 163     O << toString(APFloat(Op.getFPImm()));
 164   } else {
 165     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
 166             (MII.get(MI->getOpcode()).TSFlags &
 167              WebAssemblyII::VariableOpIsImmediate)) &&
 168            "WebAssemblyII::VariableOpIsImmediate should be set for "
 169            "variable_ops expr ops");
 170     assert(Op.isExpr() && "unknown operand kind in printOperand");
 171     Op.getExpr()->print(O, &MAI);
 172   }
 173 }
 174
 175 const char *llvm::WebAssembly::TypeToString(MVT Ty) {
 176   switch (Ty.SimpleTy) {
 177   case MVT::i32:
 178     return "i32";
 179   case MVT::i64:
 180     return "i64";
 181   case MVT::f32:
 182     return "f32";
 183   case MVT::f64:
 184     return "f64";
 185   default:
 186     llvm_unreachable("unsupported type");
 187   }
 188 }