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