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 "InstPrinter/WebAssemblyInstPrinter.h"
19 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
20 #include "WebAssemblyMCInstLower.h"
21 #include "WebAssemblyMachineFunctionInfo.h"
22 #include "WebAssemblyRegisterInfo.h"
23 #include "WebAssemblySubtarget.h"
24 #include "llvm/ADT/SmallString.h"
25 #include "llvm/ADT/StringExtras.h"
26 #include "llvm/CodeGen/Analysis.h"
27 #include "llvm/CodeGen/AsmPrinter.h"
28 #include "llvm/CodeGen/MachineConstantPool.h"
29 #include "llvm/CodeGen/MachineInstr.h"
30 #include "llvm/IR/DataLayout.h"
31 #include "llvm/MC/MCContext.h"
32 #include "llvm/MC/MCStreamer.h"
33 #include "llvm/MC/MCSymbol.h"
34 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/TargetRegistry.h"
36 #include "llvm/Support/raw_ostream.h"
37 using namespace llvm;
38 
39 #define DEBUG_TYPE "asm-printer"
40 
41 namespace {
42 
43 class WebAssemblyAsmPrinter final : public AsmPrinter {
44   const MachineRegisterInfo *MRI;
45   const WebAssemblyFunctionInfo *MFI;
46 
47 public:
48   WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
49       : AsmPrinter(TM, std::move(Streamer)), MRI(nullptr), MFI(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     MRI = &MF.getRegInfo();
66     MFI = MF.getInfo<WebAssemblyFunctionInfo>();
67     return AsmPrinter::runOnMachineFunction(MF);
68   }
69 
70   //===------------------------------------------------------------------===//
71   // AsmPrinter Implementation.
72   //===------------------------------------------------------------------===//
73 
74   void EmitJumpTableInfo() override;
75   void EmitConstantPool() override;
76   void EmitFunctionBodyStart() override;
77   void EmitInstruction(const MachineInstr *MI) override;
78   void EmitEndOfAsmFile(Module &M) override;
79   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
80                        unsigned AsmVariant, const char *ExtraCode,
81                        raw_ostream &OS) override;
82   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
83                              unsigned AsmVariant, const char *ExtraCode,
84                              raw_ostream &OS) override;
85 
86   MVT getRegType(unsigned RegNo) const;
87   const char *toString(MVT VT) const;
88   std::string regToString(const MachineOperand &MO);
89 };
90 
91 } // end anonymous namespace
92 
93 //===----------------------------------------------------------------------===//
94 // Helpers.
95 //===----------------------------------------------------------------------===//
96 
97 MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const {
98   const TargetRegisterClass *TRC = MRI->getRegClass(RegNo);
99   for (MVT T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64})
100     if (TRC->hasType(T))
101       return T;
102   DEBUG(errs() << "Unknown type for register number: " << RegNo);
103   llvm_unreachable("Unknown register type");
104   return MVT::Other;
105 }
106 
107 std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
108   unsigned RegNo = MO.getReg();
109   assert(TargetRegisterInfo::isVirtualRegister(RegNo) &&
110          "Unlowered physical register encountered during assembly printing");
111   assert(!MFI->isVRegStackified(RegNo));
112   unsigned WAReg = MFI->getWAReg(RegNo);
113   assert(WAReg != WebAssemblyFunctionInfo::UnusedReg);
114   return '$' + utostr(WAReg);
115 }
116 
117 const char *WebAssemblyAsmPrinter::toString(MVT VT) const {
118   return WebAssembly::TypeToString(VT);
119 }
120 
121 //===----------------------------------------------------------------------===//
122 // WebAssemblyAsmPrinter Implementation.
123 //===----------------------------------------------------------------------===//
124 
125 void WebAssemblyAsmPrinter::EmitConstantPool() {
126   assert(MF->getConstantPool()->getConstants().empty() &&
127          "WebAssembly disables constant pools");
128 }
129 
130 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
131   // Nothing to do; jump tables are incorporated into the instruction stream.
132 }
133 
134 static void ComputeLegalValueVTs(const Function &F, const TargetMachine &TM,
135                                  Type *Ty, SmallVectorImpl<MVT> &ValueVTs) {
136   const DataLayout &DL(F.getParent()->getDataLayout());
137   const WebAssemblyTargetLowering &TLI =
138       *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering();
139   SmallVector<EVT, 4> VTs;
140   ComputeValueVTs(TLI, DL, Ty, VTs);
141 
142   for (EVT VT : VTs) {
143     unsigned NumRegs = TLI.getNumRegisters(F.getContext(), VT);
144     MVT RegisterVT = TLI.getRegisterType(F.getContext(), VT);
145     for (unsigned i = 0; i != NumRegs; ++i)
146       ValueVTs.push_back(RegisterVT);
147   }
148 }
149 
150 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
151   if (!MFI->getParams().empty()) {
152     MCInst Param;
153     Param.setOpcode(WebAssembly::PARAM);
154     for (MVT VT : MFI->getParams())
155       Param.addOperand(MCOperand::createImm(VT.SimpleTy));
156     EmitToStreamer(*OutStreamer, Param);
157   }
158 
159   SmallVector<MVT, 4> ResultVTs;
160   const Function &F(*MF->getFunction());
161   ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs);
162   // If the return type needs to be legalized it will get converted into
163   // passing a pointer.
164   if (ResultVTs.size() == 1) {
165     MCInst Result;
166     Result.setOpcode(WebAssembly::RESULT);
167     Result.addOperand(MCOperand::createImm(ResultVTs.front().SimpleTy));
168     EmitToStreamer(*OutStreamer, Result);
169   }
170 
171   bool AnyWARegs = false;
172   MCInst Local;
173   Local.setOpcode(WebAssembly::LOCAL);
174   for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) {
175     unsigned VReg = TargetRegisterInfo::index2VirtReg(Idx);
176     unsigned WAReg = MFI->getWAReg(VReg);
177     // Don't declare unused registers.
178     if (WAReg == WebAssemblyFunctionInfo::UnusedReg)
179       continue;
180     // Don't redeclare parameters.
181     if (WAReg < MFI->getParams().size())
182       continue;
183     // Don't declare stackified registers.
184     if (int(WAReg) < 0)
185       continue;
186     Local.addOperand(MCOperand::createImm(getRegType(VReg).SimpleTy));
187     AnyWARegs = true;
188   }
189   if (AnyWARegs)
190     EmitToStreamer(*OutStreamer, Local);
191 
192   AsmPrinter::EmitFunctionBodyStart();
193 }
194 
195 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
196   DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
197 
198   switch (MI->getOpcode()) {
199   case WebAssembly::ARGUMENT_I32:
200   case WebAssembly::ARGUMENT_I64:
201   case WebAssembly::ARGUMENT_F32:
202   case WebAssembly::ARGUMENT_F64:
203     // These represent values which are live into the function entry, so there's
204     // no instruction to emit.
205     break;
206   case WebAssembly::LOOP_END:
207     // This is a no-op which just exists to tell AsmPrinter.cpp that there's a
208     // fallthrough which nevertheless requires a label for the destination here.
209     break;
210   default: {
211     WebAssemblyMCInstLower MCInstLowering(OutContext, *this);
212     MCInst TmpInst;
213     MCInstLowering.Lower(MI, TmpInst);
214     EmitToStreamer(*OutStreamer, TmpInst);
215     break;
216   }
217   }
218 }
219 
220 void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) {
221   const DataLayout &DL = M.getDataLayout();
222 
223   SmallString<128> Str;
224   raw_svector_ostream OS(Str);
225   for (const Function &F : M)
226     if (F.isDeclarationForLinker()) {
227       assert(F.hasName() && "imported functions must have a name");
228       if (F.isIntrinsic())
229         continue;
230       if (Str.empty())
231         OS << "\t.imports\n";
232 
233       MCSymbol *Sym = OutStreamer->getContext().getOrCreateSymbol(F.getName());
234       OS << "\t.import " << *Sym << " \"\" " << *Sym;
235 
236       const WebAssemblyTargetLowering &TLI =
237           *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering();
238 
239       // If we need to legalize the return type, it'll get converted into
240       // passing a pointer.
241       bool SawParam = false;
242       SmallVector<MVT, 4> ResultVTs;
243       ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs);
244       if (ResultVTs.size() > 1) {
245         ResultVTs.clear();
246         OS << " (param " << toString(TLI.getPointerTy(DL));
247         SawParam = true;
248       }
249 
250       for (const Argument &A : F.args()) {
251         SmallVector<MVT, 4> ParamVTs;
252         ComputeLegalValueVTs(F, TM, A.getType(), ParamVTs);
253         for (MVT VT : ParamVTs) {
254           if (!SawParam) {
255             OS << " (param";
256             SawParam = true;
257           }
258           OS << ' ' << toString(VT);
259         }
260       }
261       if (SawParam)
262         OS << ')';
263 
264       for (MVT VT : ResultVTs)
265         OS << " (result " << toString(VT) << ')';
266 
267       OS << '\n';
268     }
269 
270   StringRef Text = OS.str();
271   if (!Text.empty())
272     OutStreamer->EmitRawText(Text.substr(0, Text.size() - 1));
273 
274   AsmPrinter::EmitEndOfAsmFile(M);
275 }
276 
277 bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI,
278                                             unsigned OpNo, unsigned AsmVariant,
279                                             const char *ExtraCode,
280                                             raw_ostream &OS) {
281   if (AsmVariant != 0)
282     report_fatal_error("There are no defined alternate asm variants");
283 
284   if (!ExtraCode) {
285     const MachineOperand &MO = MI->getOperand(OpNo);
286     if (MO.isImm())
287       OS << MO.getImm();
288     else
289       OS << regToString(MO);
290     return false;
291   }
292 
293   return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS);
294 }
295 
296 bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
297                                                   unsigned OpNo,
298                                                   unsigned AsmVariant,
299                                                   const char *ExtraCode,
300                                                   raw_ostream &OS) {
301   if (AsmVariant != 0)
302     report_fatal_error("There are no defined alternate asm variants");
303 
304   if (!ExtraCode) {
305     OS << regToString(MI->getOperand(OpNo));
306     return false;
307   }
308 
309   return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, AsmVariant, ExtraCode, OS);
310 }
311 
312 // Force static initialization.
313 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
314   RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32);
315   RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64);
316 }
317