WebAssemblyAsmPrinter.cpp revision 292915
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/StringExtras.h" 25#include "llvm/CodeGen/Analysis.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/MC/MCContext.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" 36using namespace llvm; 37 38#define DEBUG_TYPE "asm-printer" 39 40namespace { 41 42class WebAssemblyAsmPrinter final : public AsmPrinter { 43 const MachineRegisterInfo *MRI; 44 const WebAssemblyFunctionInfo *MFI; 45 46public: 47 WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer) 48 : AsmPrinter(TM, std::move(Streamer)), MRI(nullptr), MFI(nullptr) {} 49 50private: 51 const char *getPassName() const override { 52 return "WebAssembly Assembly Printer"; 53 } 54 55 //===------------------------------------------------------------------===// 56 // MachineFunctionPass Implementation. 57 //===------------------------------------------------------------------===// 58 59 bool runOnMachineFunction(MachineFunction &MF) override { 60 MRI = &MF.getRegInfo(); 61 MFI = MF.getInfo<WebAssemblyFunctionInfo>(); 62 return AsmPrinter::runOnMachineFunction(MF); 63 } 64 65 //===------------------------------------------------------------------===// 66 // AsmPrinter Implementation. 67 //===------------------------------------------------------------------===// 68 69 void EmitJumpTableInfo() override; 70 void EmitConstantPool() override; 71 void EmitFunctionBodyStart() override; 72 void EmitInstruction(const MachineInstr *MI) override; 73 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, 74 unsigned AsmVariant, const char *ExtraCode, 75 raw_ostream &OS) override; 76 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, 77 unsigned AsmVariant, const char *ExtraCode, 78 raw_ostream &OS) override; 79 80 MVT getRegType(unsigned RegNo) const; 81 const char *toString(MVT VT) const; 82 std::string regToString(const MachineOperand &MO); 83}; 84 85} // end anonymous namespace 86 87//===----------------------------------------------------------------------===// 88// Helpers. 89//===----------------------------------------------------------------------===// 90 91MVT WebAssemblyAsmPrinter::getRegType(unsigned RegNo) const { 92 const TargetRegisterClass *TRC = 93 TargetRegisterInfo::isVirtualRegister(RegNo) ? 94 MRI->getRegClass(RegNo) : 95 MRI->getTargetRegisterInfo()->getMinimalPhysRegClass(RegNo); 96 for (MVT T : {MVT::i32, MVT::i64, MVT::f32, MVT::f64}) 97 if (TRC->hasType(T)) 98 return T; 99 DEBUG(errs() << "Unknown type for register number: " << RegNo); 100 llvm_unreachable("Unknown register type"); 101 return MVT::Other; 102} 103 104std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) { 105 unsigned RegNo = MO.getReg(); 106 assert(TargetRegisterInfo::isVirtualRegister(RegNo) && 107 "Unlowered physical register encountered during assembly printing"); 108 assert(!MFI->isVRegStackified(RegNo)); 109 unsigned WAReg = MFI->getWAReg(RegNo); 110 assert(WAReg != WebAssemblyFunctionInfo::UnusedReg); 111 return '$' + utostr(WAReg); 112} 113 114const char *WebAssemblyAsmPrinter::toString(MVT VT) const { 115 return WebAssembly::TypeToString(VT); 116} 117 118//===----------------------------------------------------------------------===// 119// WebAssemblyAsmPrinter Implementation. 120//===----------------------------------------------------------------------===// 121 122void WebAssemblyAsmPrinter::EmitConstantPool() { 123 assert(MF->getConstantPool()->getConstants().empty() && 124 "WebAssembly disables constant pools"); 125} 126 127void WebAssemblyAsmPrinter::EmitJumpTableInfo() { 128 // Nothing to do; jump tables are incorporated into the instruction stream. 129} 130 131static void ComputeLegalValueVTs(const Function &F, const TargetMachine &TM, 132 Type *Ty, SmallVectorImpl<MVT> &ValueVTs) { 133 const DataLayout &DL(F.getParent()->getDataLayout()); 134 const WebAssemblyTargetLowering &TLI = 135 *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering(); 136 SmallVector<EVT, 4> VTs; 137 ComputeValueVTs(TLI, DL, Ty, VTs); 138 139 for (EVT VT : VTs) { 140 unsigned NumRegs = TLI.getNumRegisters(F.getContext(), VT); 141 MVT RegisterVT = TLI.getRegisterType(F.getContext(), VT); 142 for (unsigned i = 0; i != NumRegs; ++i) 143 ValueVTs.push_back(RegisterVT); 144 } 145} 146 147void WebAssemblyAsmPrinter::EmitFunctionBodyStart() { 148 if (!MFI->getParams().empty()) { 149 MCInst Param; 150 Param.setOpcode(WebAssembly::PARAM); 151 for (MVT VT : MFI->getParams()) 152 Param.addOperand(MCOperand::createImm(VT.SimpleTy)); 153 EmitToStreamer(*OutStreamer, Param); 154 } 155 156 SmallVector<MVT, 4> ResultVTs; 157 const Function &F(*MF->getFunction()); 158 ComputeLegalValueVTs(F, TM, F.getReturnType(), ResultVTs); 159 // If the return type needs to be legalized it will get converted into 160 // passing a pointer. 161 if (ResultVTs.size() == 1) { 162 MCInst Result; 163 Result.setOpcode(WebAssembly::RESULT); 164 Result.addOperand(MCOperand::createImm(ResultVTs.front().SimpleTy)); 165 EmitToStreamer(*OutStreamer, Result); 166 } 167 168 bool AnyWARegs = false; 169 MCInst Local; 170 Local.setOpcode(WebAssembly::LOCAL); 171 for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) { 172 unsigned VReg = TargetRegisterInfo::index2VirtReg(Idx); 173 unsigned WAReg = MFI->getWAReg(VReg); 174 // Don't declare unused registers. 175 if (WAReg == WebAssemblyFunctionInfo::UnusedReg) 176 continue; 177 // Don't redeclare parameters. 178 if (WAReg < MFI->getParams().size()) 179 continue; 180 // Don't declare stackified registers. 181 if (int(WAReg) < 0) 182 continue; 183 Local.addOperand(MCOperand::createImm(getRegType(VReg).SimpleTy)); 184 AnyWARegs = true; 185 } 186 auto &PhysRegs = MFI->getPhysRegs(); 187 for (unsigned PReg = 0; PReg < PhysRegs.size(); ++PReg) { 188 if (PhysRegs[PReg] == -1U) 189 continue; 190 Local.addOperand(MCOperand::createImm(getRegType(PReg).SimpleTy)); 191 AnyWARegs = true; 192 } 193 if (AnyWARegs) 194 EmitToStreamer(*OutStreamer, Local); 195 196 AsmPrinter::EmitFunctionBodyStart(); 197} 198 199void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) { 200 DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n'); 201 202 switch (MI->getOpcode()) { 203 case WebAssembly::ARGUMENT_I32: 204 case WebAssembly::ARGUMENT_I64: 205 case WebAssembly::ARGUMENT_F32: 206 case WebAssembly::ARGUMENT_F64: 207 // These represent values which are live into the function entry, so there's 208 // no instruction to emit. 209 break; 210 case WebAssembly::LOOP_END: 211 // This is a no-op which just exists to tell AsmPrinter.cpp that there's a 212 // fallthrough which nevertheless requires a label for the destination here. 213 break; 214 default: { 215 WebAssemblyMCInstLower MCInstLowering(OutContext, *this); 216 MCInst TmpInst; 217 MCInstLowering.Lower(MI, TmpInst); 218 EmitToStreamer(*OutStreamer, TmpInst); 219 break; 220 } 221 } 222} 223 224bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI, 225 unsigned OpNo, unsigned AsmVariant, 226 const char *ExtraCode, 227 raw_ostream &OS) { 228 if (AsmVariant != 0) 229 report_fatal_error("There are no defined alternate asm variants"); 230 231 // First try the generic code, which knows about modifiers like 'c' and 'n'. 232 if (!AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS)) 233 return false; 234 235 if (!ExtraCode) { 236 const MachineOperand &MO = MI->getOperand(OpNo); 237 switch (MO.getType()) { 238 case MachineOperand::MO_Immediate: 239 OS << MO.getImm(); 240 return false; 241 case MachineOperand::MO_Register: 242 OS << regToString(MO); 243 return false; 244 case MachineOperand::MO_GlobalAddress: 245 getSymbol(MO.getGlobal())->print(OS, MAI); 246 printOffset(MO.getOffset(), OS); 247 return false; 248 case MachineOperand::MO_ExternalSymbol: 249 GetExternalSymbolSymbol(MO.getSymbolName())->print(OS, MAI); 250 printOffset(MO.getOffset(), OS); 251 return false; 252 case MachineOperand::MO_MachineBasicBlock: 253 MO.getMBB()->getSymbol()->print(OS, MAI); 254 return false; 255 default: 256 break; 257 } 258 } 259 260 return true; 261} 262 263bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, 264 unsigned OpNo, 265 unsigned AsmVariant, 266 const char *ExtraCode, 267 raw_ostream &OS) { 268 if (AsmVariant != 0) 269 report_fatal_error("There are no defined alternate asm variants"); 270 271 if (!ExtraCode) { 272 // TODO: For now, we just hard-code 0 as the constant offset; teach 273 // SelectInlineAsmMemoryOperand how to do address mode matching. 274 OS << "0(" + regToString(MI->getOperand(OpNo)) + ')'; 275 return false; 276 } 277 278 return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, AsmVariant, ExtraCode, OS); 279} 280 281// Force static initialization. 282extern "C" void LLVMInitializeWebAssemblyAsmPrinter() { 283 RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32); 284 RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64); 285} 286