1 //===-- WebAssemblyAsmPrinter.cpp - WebAssembly LLVM assembly writer ------===//
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 contains a printer that converts from our internal
12 /// representation of machine-dependent LLVM code to the WebAssembly assembly
13 /// language.
14 ///
15 //===----------------------------------------------------------------------===//
16 
17 #include "WebAssembly.h"
18 #include "WebAssemblyMachineFunctionInfo.h"
19 #include "WebAssemblyRegisterInfo.h"
20 #include "WebAssemblySubtarget.h"
21 #include "InstPrinter/WebAssemblyInstPrinter.h"
22 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
23 
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/CodeGen/AsmPrinter.h"
27 #include "llvm/CodeGen/MachineConstantPool.h"
28 #include "llvm/CodeGen/MachineInstr.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/DebugInfo.h"
31 #include "llvm/MC/MCStreamer.h"
32 #include "llvm/MC/MCSymbol.h"
33 #include "llvm/Support/Debug.h"
34 #include "llvm/Support/TargetRegistry.h"
35 #include "llvm/Support/raw_ostream.h"
36 
37 using namespace llvm;
38 
39 #define DEBUG_TYPE "asm-printer"
40 
41 namespace {
42 
43 class WebAssemblyAsmPrinter final : public AsmPrinter {
44   const WebAssemblyInstrInfo *TII;
45   unsigned NumArgs;
46 
47 public:
48   WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
49       : AsmPrinter(TM, std::move(Streamer)), TII(nullptr) {}
50 
51 private:
52   const char *getPassName() const override {
53     return "WebAssembly Assembly Printer";
54   }
55 
56   //===------------------------------------------------------------------===//
57   // MachineFunctionPass Implementation.
58   //===------------------------------------------------------------------===//
59 
60   void getAnalysisUsage(AnalysisUsage &AU) const override {
61     AsmPrinter::getAnalysisUsage(AU);
62   }
63 
64   bool runOnMachineFunction(MachineFunction &MF) override {
65     const auto &Subtarget = MF.getSubtarget<WebAssemblySubtarget>();
66     TII = Subtarget.getInstrInfo();
67     NumArgs = MF.getInfo<WebAssemblyFunctionInfo>()->getNumArguments();
68     return AsmPrinter::runOnMachineFunction(MF);
69   }
70 
71   //===------------------------------------------------------------------===//
72   // AsmPrinter Implementation.
73   //===------------------------------------------------------------------===//
74 
75   void EmitJumpTableInfo() override;
76   void EmitConstantPool() override;
77   void EmitFunctionBodyStart() override;
78 
79   void EmitInstruction(const MachineInstr *MI) override;
80 
81   static std::string toString(const APFloat &APF);
82   const char *toString(Type *Ty) const;
83   std::string regToString(unsigned RegNo);
84   std::string argToString(unsigned ArgNo);
85 };
86 
87 } // end anonymous namespace
88 
89 //===----------------------------------------------------------------------===//
90 // Helpers.
91 //===----------------------------------------------------------------------===//
92 
93 // Untyped, lower-case version of the opcode's name matching the names
94 // WebAssembly opcodes are expected to have. The tablegen names are uppercase
95 // and suffixed with their type (after an underscore).
96 static SmallString<32> OpcodeName(const WebAssemblyInstrInfo *TII,
97                                   const MachineInstr *MI) {
98   std::string N(StringRef(TII->getName(MI->getOpcode())).lower());
99   std::string::size_type End = N.rfind('_');
100   End = std::string::npos == End ? N.length() : End;
101   return SmallString<32>(&N[0], &N[End]);
102 }
103 
104 static std::string toSymbol(StringRef S) { return ("$" + S).str(); }
105 
106 std::string WebAssemblyAsmPrinter::toString(const APFloat &FP) {
107   static const size_t BufBytes = 128;
108   char buf[BufBytes];
109   if (FP.isNaN())
110     assert((FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) ||
111             FP.bitwiseIsEqual(
112                 APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) &&
113            "convertToHexString handles neither SNaN nor NaN payloads");
114   // Use C99's hexadecimal floating-point representation.
115   auto Written = FP.convertToHexString(
116       buf, /*hexDigits=*/0, /*upperCase=*/false, APFloat::rmNearestTiesToEven);
117   (void)Written;
118   assert(Written != 0);
119   assert(Written < BufBytes);
120   return buf;
121 }
122 
123 std::string WebAssemblyAsmPrinter::regToString(unsigned RegNo) {
124   if (TargetRegisterInfo::isPhysicalRegister(RegNo))
125     return WebAssemblyInstPrinter::getRegisterName(RegNo);
126 
127   // WebAssembly arguments and local variables are in the same index space, and
128   // there are no explicit varargs, so we just add the number of arguments to
129   // the virtual register number to get the local variable number.
130   return '@' + utostr(TargetRegisterInfo::virtReg2Index(RegNo) + NumArgs);
131 }
132 
133 std::string WebAssemblyAsmPrinter::argToString(unsigned ArgNo) {
134   // Same as above, but we don't need to add NumArgs here.
135   return '@' + utostr(ArgNo);
136 }
137 
138 const char *WebAssemblyAsmPrinter::toString(Type *Ty) const {
139   switch (Ty->getTypeID()) {
140   default:
141     break;
142   // Treat all pointers as the underlying integer into linear memory.
143   case Type::PointerTyID:
144     switch (getPointerSize()) {
145     case 4:
146       return "i32";
147     case 8:
148       return "i64";
149     default:
150       llvm_unreachable("unsupported pointer size");
151     }
152     break;
153   case Type::FloatTyID:
154     return "f32";
155   case Type::DoubleTyID:
156     return "f64";
157   case Type::IntegerTyID:
158     switch (Ty->getIntegerBitWidth()) {
159     case 8:
160       return "i8";
161     case 16:
162       return "i16";
163     case 32:
164       return "i32";
165     case 64:
166       return "i64";
167     default:
168       break;
169     }
170   }
171   DEBUG(dbgs() << "Invalid type "; Ty->print(dbgs()); dbgs() << '\n');
172   llvm_unreachable("invalid type");
173   return "<invalid>";
174 }
175 
176 //===----------------------------------------------------------------------===//
177 // WebAssemblyAsmPrinter Implementation.
178 //===----------------------------------------------------------------------===//
179 
180 void WebAssemblyAsmPrinter::EmitConstantPool() {
181   assert(MF->getConstantPool()->getConstants().empty() &&
182          "WebAssembly disables constant pools");
183 }
184 
185 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
186   // Nothing to do; jump tables are incorporated into the instruction stream.
187 }
188 
189 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
190   const Function *F = MF->getFunction();
191   Type *Rt = F->getReturnType();
192 
193   if (!Rt->isVoidTy() || !F->arg_empty()) {
194     SmallString<128> Str;
195     raw_svector_ostream OS(Str);
196     bool First = true;
197     for (const Argument &A : F->args()) {
198       OS << (First ? "" : "\n") << "\t"
199                                    ".param "
200          << toString(A.getType());
201       First = false;
202     }
203     if (!Rt->isVoidTy()) {
204       OS << (First ? "" : "\n") << "\t"
205                                    ".result "
206          << toString(Rt);
207       First = false;
208     }
209     OutStreamer->EmitRawText(OS.str());
210   }
211 
212   AsmPrinter::EmitFunctionBodyStart();
213 }
214 
215 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
216   DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
217   SmallString<128> Str;
218   raw_svector_ostream OS(Str);
219 
220   unsigned NumDefs = MI->getDesc().getNumDefs();
221   assert(NumDefs <= 1 &&
222          "Instructions with multiple result values not implemented");
223 
224   OS << '\t';
225 
226   switch (MI->getOpcode()) {
227   case TargetOpcode::COPY:
228     OS << regToString(MI->getOperand(1).getReg());
229     break;
230   case WebAssembly::GLOBAL:
231     // TODO: wasm64
232     OS << "i32.const " << toSymbol(MI->getOperand(1).getGlobal()->getName());
233     break;
234   case WebAssembly::ARGUMENT_I32:
235   case WebAssembly::ARGUMENT_I64:
236   case WebAssembly::ARGUMENT_F32:
237   case WebAssembly::ARGUMENT_F64:
238     OS << argToString(MI->getOperand(1).getImm());
239     break;
240   case WebAssembly::Immediate_I32:
241     OS << "i32.const " << MI->getOperand(1).getImm();
242     break;
243   case WebAssembly::Immediate_I64:
244     OS << "i64.const " << MI->getOperand(1).getImm();
245     break;
246   case WebAssembly::Immediate_F32:
247     OS << "f32.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
248     break;
249   case WebAssembly::Immediate_F64:
250     OS << "f64.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
251     break;
252   default: {
253     OS << OpcodeName(TII, MI);
254     bool NeedComma = false;
255     for (const MachineOperand &MO : MI->uses()) {
256       if (MO.isReg() && MO.isImplicit())
257         continue;
258       if (NeedComma)
259         OS << ',';
260       NeedComma = true;
261       OS << ' ';
262       switch (MO.getType()) {
263       default:
264         llvm_unreachable("unexpected machine operand type");
265       case MachineOperand::MO_Register:
266         OS << regToString(MO.getReg());
267         break;
268       case MachineOperand::MO_Immediate:
269         OS << MO.getImm();
270         break;
271       case MachineOperand::MO_FPImmediate:
272         OS << toString(MO.getFPImm()->getValueAPF());
273         break;
274       case MachineOperand::MO_GlobalAddress:
275         OS << toSymbol(MO.getGlobal()->getName());
276         break;
277       case MachineOperand::MO_MachineBasicBlock:
278         OS << toSymbol(MO.getMBB()->getSymbol()->getName());
279         break;
280       }
281     }
282     break;
283   }
284   }
285 
286   OutStreamer->EmitRawText(OS.str());
287 
288   if (NumDefs != 0) {
289     SmallString<128> Str;
290     raw_svector_ostream OS(Str);
291     OS << "\t" "set_local "
292        << regToString(MI->getOperand(0).getReg()) << ", "
293           "pop";
294     OutStreamer->EmitRawText(OS.str());
295   }
296 }
297 
298 // Force static initialization.
299 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
300   RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32);
301   RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64);
302 }
303