[WebAssembly] Make CFG stackification independent of basic-block labels.
[oota-llvm.git] / 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     if (MII.get(MI->getOpcode()).TSFlags &
155         WebAssemblyII::VariableOpImmediateIsType)
156       // The immediates represent types.
157       O << WebAssembly::TypeToString(MVT::SimpleValueType(Op.getImm()));
158     else
159       O << Op.getImm();
160   } else if (Op.isFPImm()) {
161     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
162             MII.get(MI->getOpcode()).TSFlags == 0) &&
163            "WebAssembly variable_ops floating point ops don't use TSFlags");
164     O << toString(APFloat(Op.getFPImm()));
165   } else {
166     assert((OpNo < MII.get(MI->getOpcode()).getNumOperands() ||
167             (MII.get(MI->getOpcode()).TSFlags &
168              WebAssemblyII::VariableOpIsImmediate)) &&
169            "WebAssemblyII::VariableOpIsImmediate should be set for "
170            "variable_ops expr ops");
171     assert(Op.isExpr() && "unknown operand kind in printOperand");
172     Op.getExpr()->print(O, &MAI);
173   }
174 }
175
176 const char *llvm::WebAssembly::TypeToString(MVT Ty) {
177   switch (Ty.SimpleTy) {
178   case MVT::i32:
179     return "i32";
180   case MVT::i64:
181     return "i64";
182   case MVT::f32:
183     return "f32";
184   case MVT::f64:
185     return "f64";
186   default:
187     llvm_unreachable("unsupported type");
188   }
189 }