1 //===-- WebAssemblyAsmPrinter.cpp - WebAssembly LLVM assembly writer ------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
11 /// \brief This file contains a printer that converts from our internal
12 /// representation of machine-dependent LLVM code to the WebAssembly assembly
15 //===----------------------------------------------------------------------===//
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"
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"
39 #define DEBUG_TYPE "asm-printer"
43 class WebAssemblyAsmPrinter final : public AsmPrinter {
44 const WebAssemblyInstrInfo *TII;
45 const MachineRegisterInfo *MRI;
49 WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
50 : AsmPrinter(TM, std::move(Streamer)), TII(nullptr), MRI(nullptr) {}
53 const char *getPassName() const override {
54 return "WebAssembly Assembly Printer";
57 //===------------------------------------------------------------------===//
58 // MachineFunctionPass Implementation.
59 //===------------------------------------------------------------------===//
61 void getAnalysisUsage(AnalysisUsage &AU) const override {
62 AsmPrinter::getAnalysisUsage(AU);
65 bool runOnMachineFunction(MachineFunction &MF) override {
66 const auto &Subtarget = MF.getSubtarget<WebAssemblySubtarget>();
67 TII = Subtarget.getInstrInfo();
68 MRI = &MF.getRegInfo();
69 NumArgs = MF.getInfo<WebAssemblyFunctionInfo>()->getNumArguments();
70 return AsmPrinter::runOnMachineFunction(MF);
73 //===------------------------------------------------------------------===//
74 // AsmPrinter Implementation.
75 //===------------------------------------------------------------------===//
77 void EmitJumpTableInfo() override;
78 void EmitConstantPool() override;
79 void EmitFunctionBodyStart() override;
81 void EmitInstruction(const MachineInstr *MI) override;
83 std::string getRegTypeName(unsigned RegNo) const;
84 static std::string toString(const APFloat &APF);
85 const char *toString(Type *Ty) const;
86 std::string regToString(const MachineOperand &MO);
87 std::string argToString(const MachineOperand &MO);
90 } // end anonymous namespace
92 //===----------------------------------------------------------------------===//
94 //===----------------------------------------------------------------------===//
96 // Operand type (if any), followed by the lower-case version of the opcode's
97 // name matching the names WebAssembly opcodes are expected to have. The
98 // tablegen names are uppercase and suffixed with their type (after an
100 static std::string OpcodeName(const WebAssemblyInstrInfo *TII,
101 const MachineInstr *MI) {
102 std::string N(StringRef(TII->getName(MI->getOpcode())).lower());
103 std::string::size_type Len = N.length();
104 std::string::size_type Under = N.rfind('_');
105 bool HasType = std::string::npos != Under;
106 std::string::size_type NameEnd = HasType ? Under : Len;
107 std::string Name(&N[0], &N[NameEnd]);
108 return HasType ? (std::string(&N[NameEnd + 1], &N[Len]) + '.' + Name) : Name;
111 static std::string toSymbol(StringRef S) { return ("$" + S).str(); }
113 std::string WebAssemblyAsmPrinter::getRegTypeName(unsigned RegNo) const {
114 const TargetRegisterClass *TRC = MRI->getRegClass(RegNo);
115 for (MVT T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64})
117 return EVT(T).getEVTString();
118 DEBUG(errs() << "Unknown type for register number: " << RegNo);
119 llvm_unreachable("Unknown register type");
123 std::string WebAssemblyAsmPrinter::toString(const APFloat &FP) {
124 static const size_t BufBytes = 128;
127 assert((FP.bitwiseIsEqual(APFloat::getQNaN(FP.getSemantics())) ||
129 APFloat::getQNaN(FP.getSemantics(), /*Negative=*/true))) &&
130 "convertToHexString handles neither SNaN nor NaN payloads");
131 // Use C99's hexadecimal floating-point representation.
132 auto Written = FP.convertToHexString(
133 buf, /*hexDigits=*/0, /*upperCase=*/false, APFloat::rmNearestTiesToEven);
135 assert(Written != 0);
136 assert(Written < BufBytes);
140 std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) {
141 unsigned RegNo = MO.getReg();
142 if (TargetRegisterInfo::isPhysicalRegister(RegNo))
143 return WebAssemblyInstPrinter::getRegisterName(RegNo);
145 // WebAssembly arguments and local variables are in the same index space, and
146 // there are no explicit varargs, so we just add the number of arguments to
147 // the virtual register number to get the local variable number.
148 return utostr(TargetRegisterInfo::virtReg2Index(RegNo) + NumArgs);
151 std::string WebAssemblyAsmPrinter::argToString(const MachineOperand &MO) {
152 unsigned ArgNo = MO.getImm();
153 // Same as above, but we don't need to add NumArgs here.
154 return utostr(ArgNo);
157 const char *WebAssemblyAsmPrinter::toString(Type *Ty) const {
158 switch (Ty->getTypeID()) {
161 // Treat all pointers as the underlying integer into linear memory.
162 case Type::PointerTyID:
163 switch (getPointerSize()) {
169 llvm_unreachable("unsupported pointer size");
172 case Type::FloatTyID:
174 case Type::DoubleTyID:
176 case Type::IntegerTyID:
177 switch (Ty->getIntegerBitWidth()) {
190 DEBUG(dbgs() << "Invalid type "; Ty->print(dbgs()); dbgs() << '\n');
191 llvm_unreachable("invalid type");
195 //===----------------------------------------------------------------------===//
196 // WebAssemblyAsmPrinter Implementation.
197 //===----------------------------------------------------------------------===//
199 void WebAssemblyAsmPrinter::EmitConstantPool() {
200 assert(MF->getConstantPool()->getConstants().empty() &&
201 "WebAssembly disables constant pools");
204 void WebAssemblyAsmPrinter::EmitJumpTableInfo() {
205 // Nothing to do; jump tables are incorporated into the instruction stream.
208 void WebAssemblyAsmPrinter::EmitFunctionBodyStart() {
209 const Function *F = MF->getFunction();
210 Type *Rt = F->getReturnType();
211 SmallString<128> Str;
212 raw_svector_ostream OS(Str);
215 if (!Rt->isVoidTy() || !F->arg_empty()) {
216 for (const Argument &A : F->args()) {
217 OS << (First ? "" : "\n") << "\t.param " << toString(A.getType());
220 if (!Rt->isVoidTy()) {
221 OS << (First ? "" : "\n") << "\t.result " << toString(Rt);
226 bool FirstVReg = true;
227 for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) {
228 unsigned VReg = TargetRegisterInfo::index2VirtReg(Idx);
229 if (!MRI->use_empty(VReg)) {
231 OS << (First ? "" : "\n") << "\t.local ";
234 OS << (FirstVReg ? "" : ", ") << getRegTypeName(VReg);
240 OutStreamer->EmitRawText(OS.str());
241 AsmPrinter::EmitFunctionBodyStart();
244 void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) {
245 DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n');
246 SmallString<128> Str;
247 raw_svector_ostream OS(Str);
249 unsigned NumDefs = MI->getDesc().getNumDefs();
250 assert(NumDefs <= 1 &&
251 "Instructions with multiple result values not implemented");
255 switch (MI->getOpcode()) {
256 case TargetOpcode::COPY:
257 OS << "get_local " << regToString(MI->getOperand(1));
259 case WebAssembly::GLOBAL:
261 OS << "i32.const " << toSymbol(MI->getOperand(1).getGlobal()->getName());
263 case WebAssembly::ARGUMENT_I32:
264 case WebAssembly::ARGUMENT_I64:
265 case WebAssembly::ARGUMENT_F32:
266 case WebAssembly::ARGUMENT_F64:
267 OS << "get_local " << argToString(MI->getOperand(1));
269 case WebAssembly::Immediate_I32:
270 OS << "i32.const " << MI->getOperand(1).getImm();
272 case WebAssembly::Immediate_I64:
273 OS << "i64.const " << MI->getOperand(1).getImm();
275 case WebAssembly::Immediate_F32:
276 OS << "f32.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
278 case WebAssembly::Immediate_F64:
279 OS << "f64.const " << toString(MI->getOperand(1).getFPImm()->getValueAPF());
282 OS << OpcodeName(TII, MI);
283 bool NeedComma = false;
284 for (const MachineOperand &MO : MI->uses()) {
285 if (MO.isReg() && MO.isImplicit())
291 switch (MO.getType()) {
293 llvm_unreachable("unexpected machine operand type");
294 case MachineOperand::MO_Register:
295 OS << "(get_local " << regToString(MO) << ')';
297 case MachineOperand::MO_Immediate:
300 case MachineOperand::MO_FPImmediate:
301 OS << toString(MO.getFPImm()->getValueAPF());
303 case MachineOperand::MO_GlobalAddress:
304 OS << toSymbol(MO.getGlobal()->getName());
306 case MachineOperand::MO_MachineBasicBlock:
307 OS << toSymbol(MO.getMBB()->getSymbol()->getName());
315 OutStreamer->EmitRawText(OS.str());
318 SmallString<128> Str;
319 raw_svector_ostream OS(Str);
320 const MachineOperand &Operand = MI->getOperand(0);
321 OS << "\tset_local " << regToString(Operand) << ", pop";
322 OutStreamer->EmitRawText(OS.str());
326 // Force static initialization.
327 extern "C" void LLVMInitializeWebAssemblyAsmPrinter() {
328 RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32);
329 RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64);