JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 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" |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 18 | #include "InstPrinter/WebAssemblyInstPrinter.h" |
| 19 | #include "MCTargetDesc/WebAssemblyMCTargetDesc.h" |
| 20 | #include "WebAssemblyMCInstLower.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 21 | #include "WebAssemblyMachineFunctionInfo.h" |
| 22 | #include "WebAssemblyRegisterInfo.h" |
| 23 | #include "WebAssemblySubtarget.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 24 | #include "llvm/ADT/SmallString.h" |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/StringExtras.h" |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 26 | #include "llvm/CodeGen/Analysis.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 27 | #include "llvm/CodeGen/AsmPrinter.h" |
JF Bastien | 54be3b1 | 2015-08-25 23:19:49 +0000 | [diff] [blame] | 28 | #include "llvm/CodeGen/MachineConstantPool.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 29 | #include "llvm/CodeGen/MachineInstr.h" |
| 30 | #include "llvm/IR/DataLayout.h" |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 31 | #include "llvm/MC/MCContext.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 32 | #include "llvm/MC/MCStreamer.h" |
JF Bastien | b6091df | 2015-08-25 22:58:05 +0000 | [diff] [blame] | 33 | #include "llvm/MC/MCSymbol.h" |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 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 { |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 45 | const MachineRegisterInfo *MRI; |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 46 | const WebAssemblyFunctionInfo *MFI; |
JF Bastien | 600aee9 | 2015-07-31 17:53:38 +0000 | [diff] [blame] | 47 | |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 48 | public: |
| 49 | WebAssemblyAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer) |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 50 | : AsmPrinter(TM, std::move(Streamer)), MRI(nullptr), MFI(nullptr) {} |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 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 | |
JF Bastien | 600aee9 | 2015-07-31 17:53:38 +0000 | [diff] [blame] | 65 | bool runOnMachineFunction(MachineFunction &MF) override { |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 66 | MRI = &MF.getRegInfo(); |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 67 | MFI = MF.getInfo<WebAssemblyFunctionInfo>(); |
JF Bastien | 600aee9 | 2015-07-31 17:53:38 +0000 | [diff] [blame] | 68 | return AsmPrinter::runOnMachineFunction(MF); |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 69 | } |
| 70 | |
| 71 | //===------------------------------------------------------------------===// |
| 72 | // AsmPrinter Implementation. |
| 73 | //===------------------------------------------------------------------===// |
| 74 | |
Dan Gohman | 950a13c | 2015-09-16 16:51:30 +0000 | [diff] [blame] | 75 | void EmitJumpTableInfo() override; |
JF Bastien | 54be3b1 | 2015-08-25 23:19:49 +0000 | [diff] [blame] | 76 | void EmitConstantPool() override; |
JF Bastien | b6091df | 2015-08-25 22:58:05 +0000 | [diff] [blame] | 77 | void EmitFunctionBodyStart() override; |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 78 | void EmitInstruction(const MachineInstr *MI) override; |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 79 | void EmitEndOfAsmFile(Module &M) override; |
Dan Gohman | f19ed56 | 2015-11-13 01:42:29 +0000 | [diff] [blame^] | 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; |
Dan Gohman | 979840d | 2015-09-23 16:59:10 +0000 | [diff] [blame] | 86 | |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 87 | std::string getRegTypeName(unsigned RegNo) const; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 88 | const char *toString(MVT VT) const; |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 89 | std::string regToString(const MachineOperand &MO); |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 90 | }; |
| 91 | |
| 92 | } // end anonymous namespace |
| 93 | |
| 94 | //===----------------------------------------------------------------------===// |
JF Bastien | 45479f6 | 2015-08-26 22:09:54 +0000 | [diff] [blame] | 95 | // Helpers. |
| 96 | //===----------------------------------------------------------------------===// |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 97 | |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 98 | std::string WebAssemblyAsmPrinter::getRegTypeName(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 EVT(T).getEVTString(); |
| 103 | DEBUG(errs() << "Unknown type for register number: " << RegNo); |
| 104 | llvm_unreachable("Unknown register type"); |
| 105 | return "?"; |
| 106 | } |
| 107 | |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 108 | std::string WebAssemblyAsmPrinter::regToString(const MachineOperand &MO) { |
| 109 | unsigned RegNo = MO.getReg(); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 110 | if (TargetRegisterInfo::isPhysicalRegister(RegNo)) |
| 111 | return WebAssemblyInstPrinter::getRegisterName(RegNo); |
| 112 | |
Dan Gohman | 058fce5 | 2015-11-13 00:21:05 +0000 | [diff] [blame] | 113 | unsigned WAReg = MFI->getWAReg(RegNo); |
| 114 | assert(WAReg != WebAssemblyFunctionInfo::UnusedReg); |
| 115 | return utostr(WAReg); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 116 | } |
| 117 | |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 118 | const char *WebAssemblyAsmPrinter::toString(MVT VT) const { |
| 119 | switch (VT.SimpleTy) { |
Dan Gohman | 979840d | 2015-09-23 16:59:10 +0000 | [diff] [blame] | 120 | default: |
| 121 | break; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 122 | case MVT::f32: |
Dan Gohman | 979840d | 2015-09-23 16:59:10 +0000 | [diff] [blame] | 123 | return "f32"; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 124 | case MVT::f64: |
Dan Gohman | 979840d | 2015-09-23 16:59:10 +0000 | [diff] [blame] | 125 | return "f64"; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 126 | case MVT::i32: |
| 127 | return "i32"; |
| 128 | case MVT::i64: |
| 129 | return "i64"; |
JF Bastien | 73ff6af | 2015-08-31 22:24:11 +0000 | [diff] [blame] | 130 | } |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 131 | DEBUG(dbgs() << "Invalid type " << EVT(VT).getEVTString() << '\n'); |
JF Bastien | 73ff6af | 2015-08-31 22:24:11 +0000 | [diff] [blame] | 132 | llvm_unreachable("invalid type"); |
| 133 | return "<invalid>"; |
| 134 | } |
| 135 | |
JF Bastien | 45479f6 | 2015-08-26 22:09:54 +0000 | [diff] [blame] | 136 | //===----------------------------------------------------------------------===// |
| 137 | // WebAssemblyAsmPrinter Implementation. |
| 138 | //===----------------------------------------------------------------------===// |
| 139 | |
JF Bastien | 54be3b1 | 2015-08-25 23:19:49 +0000 | [diff] [blame] | 140 | void WebAssemblyAsmPrinter::EmitConstantPool() { |
| 141 | assert(MF->getConstantPool()->getConstants().empty() && |
| 142 | "WebAssembly disables constant pools"); |
| 143 | } |
| 144 | |
Dan Gohman | 950a13c | 2015-09-16 16:51:30 +0000 | [diff] [blame] | 145 | void WebAssemblyAsmPrinter::EmitJumpTableInfo() { |
| 146 | // Nothing to do; jump tables are incorporated into the instruction stream. |
| 147 | } |
| 148 | |
JF Bastien | b6091df | 2015-08-25 22:58:05 +0000 | [diff] [blame] | 149 | void WebAssemblyAsmPrinter::EmitFunctionBodyStart() { |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 150 | SmallString<128> Str; |
| 151 | raw_svector_ostream OS(Str); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 152 | |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 153 | for (MVT VT : MFI->getParams()) |
| 154 | OS << "\t" ".param " << toString(VT) << '\n'; |
| 155 | for (MVT VT : MFI->getResults()) |
| 156 | OS << "\t" ".result " << toString(VT) << '\n'; |
JF Bastien | b6091df | 2015-08-25 22:58:05 +0000 | [diff] [blame] | 157 | |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 158 | bool FirstVReg = true; |
| 159 | for (unsigned Idx = 0, IdxE = MRI->getNumVirtRegs(); Idx != IdxE; ++Idx) { |
| 160 | unsigned VReg = TargetRegisterInfo::index2VirtReg(Idx); |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 161 | if (!MRI->use_empty(VReg)) { |
| 162 | if (FirstVReg) |
| 163 | OS << "\t" ".local "; |
| 164 | else |
| 165 | OS << ", "; |
| 166 | OS << getRegTypeName(VReg); |
| 167 | FirstVReg = false; |
| 168 | } |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 169 | } |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 170 | if (!FirstVReg) |
| 171 | OS << '\n'; |
JF Bastien | 1d20a5e | 2015-10-16 00:53:49 +0000 | [diff] [blame] | 172 | |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 173 | // EmitRawText appends a newline, so strip off the last newline. |
| 174 | StringRef Text = OS.str(); |
| 175 | if (!Text.empty()) |
| 176 | OutStreamer->EmitRawText(Text.substr(0, Text.size() - 1)); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 177 | AsmPrinter::EmitFunctionBodyStart(); |
JF Bastien | b6091df | 2015-08-25 22:58:05 +0000 | [diff] [blame] | 178 | } |
| 179 | |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 180 | void WebAssemblyAsmPrinter::EmitInstruction(const MachineInstr *MI) { |
JF Bastien | af111db | 2015-08-24 22:16:48 +0000 | [diff] [blame] | 181 | DEBUG(dbgs() << "EmitInstruction: " << *MI << '\n'); |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 182 | |
David Blaikie | b0311c5 | 2015-11-12 19:07:43 +0000 | [diff] [blame] | 183 | assert(MI->getDesc().getNumDefs() <= 1 && |
JF Bastien | 600aee9 | 2015-07-31 17:53:38 +0000 | [diff] [blame] | 184 | "Instructions with multiple result values not implemented"); |
| 185 | |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 186 | switch (MI->getOpcode()) { |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 187 | case TargetOpcode::COPY: { |
| 188 | // TODO: Figure out a way to lower COPY instructions to MCInst form. |
| 189 | SmallString<128> Str; |
| 190 | raw_svector_ostream OS(Str); |
| 191 | OS << "\t" "set_local " << regToString(MI->getOperand(0)) << ", " |
| 192 | "(get_local " << regToString(MI->getOperand(1)) << ")"; |
| 193 | OutStreamer->EmitRawText(OS.str()); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 194 | break; |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 195 | } |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 196 | case WebAssembly::ARGUMENT_I32: |
| 197 | case WebAssembly::ARGUMENT_I64: |
| 198 | case WebAssembly::ARGUMENT_F32: |
| 199 | case WebAssembly::ARGUMENT_F64: |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 200 | // These represent values which are live into the function entry, so there's |
| 201 | // no instruction to emit. |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 202 | break; |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 203 | default: { |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 204 | WebAssemblyMCInstLower MCInstLowering(OutContext, *this); |
| 205 | MCInst TmpInst; |
| 206 | MCInstLowering.Lower(MI, TmpInst); |
| 207 | EmitToStreamer(*OutStreamer, TmpInst); |
Dan Gohman | e51c058 | 2015-10-06 00:27:55 +0000 | [diff] [blame] | 208 | break; |
| 209 | } |
Dan Gohman | 4f52e00 | 2015-09-09 00:52:47 +0000 | [diff] [blame] | 210 | } |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 211 | } |
| 212 | |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 213 | static void ComputeLegalValueVTs(LLVMContext &Context, |
| 214 | const WebAssemblyTargetLowering &TLI, |
| 215 | const DataLayout &DL, Type *Ty, |
| 216 | SmallVectorImpl<MVT> &ValueVTs) { |
| 217 | SmallVector<EVT, 4> VTs; |
| 218 | ComputeValueVTs(TLI, DL, Ty, VTs); |
| 219 | |
| 220 | for (EVT VT : VTs) { |
| 221 | unsigned NumRegs = TLI.getNumRegisters(Context, VT); |
| 222 | MVT RegisterVT = TLI.getRegisterType(Context, VT); |
| 223 | for (unsigned i = 0; i != NumRegs; ++i) |
| 224 | ValueVTs.push_back(RegisterVT); |
| 225 | } |
| 226 | } |
| 227 | |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 228 | void WebAssemblyAsmPrinter::EmitEndOfAsmFile(Module &M) { |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 229 | const DataLayout &DL = M.getDataLayout(); |
| 230 | |
JF Bastien | 5789a69 | 2015-10-30 16:41:21 +0000 | [diff] [blame] | 231 | SmallString<128> Str; |
| 232 | raw_svector_ostream OS(Str); |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 233 | for (const Function &F : M) |
| 234 | if (F.isDeclarationForLinker()) { |
| 235 | assert(F.hasName() && "imported functions must have a name"); |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 236 | if (F.isIntrinsic()) |
JF Bastien | 5789a69 | 2015-10-30 16:41:21 +0000 | [diff] [blame] | 237 | continue; |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 238 | if (Str.empty()) |
JF Bastien | 5789a69 | 2015-10-30 16:41:21 +0000 | [diff] [blame] | 239 | OS << "\t.imports\n"; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 240 | |
Dan Gohman | cf4748f | 2015-11-12 17:04:33 +0000 | [diff] [blame] | 241 | MCSymbol *Sym = OutStreamer->getContext().getOrCreateSymbol(F.getName()); |
| 242 | OS << "\t.import " << *Sym << " \"\" " << *Sym; |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 243 | |
| 244 | const WebAssemblyTargetLowering &TLI = |
| 245 | *TM.getSubtarget<WebAssemblySubtarget>(F).getTargetLowering(); |
| 246 | |
| 247 | // If we need to legalize the return type, it'll get converted into |
| 248 | // passing a pointer. |
| 249 | bool SawParam = false; |
| 250 | SmallVector<MVT, 4> ResultVTs; |
| 251 | ComputeLegalValueVTs(M.getContext(), TLI, DL, F.getReturnType(), |
| 252 | ResultVTs); |
| 253 | if (ResultVTs.size() > 1) { |
| 254 | ResultVTs.clear(); |
| 255 | OS << " (param " << toString(TLI.getPointerTy(DL)); |
| 256 | SawParam = true; |
| 257 | } |
| 258 | |
| 259 | for (const Argument &A : F.args()) { |
| 260 | SmallVector<MVT, 4> ParamVTs; |
| 261 | ComputeLegalValueVTs(M.getContext(), TLI, DL, A.getType(), ParamVTs); |
| 262 | for (EVT VT : ParamVTs) { |
| 263 | if (!SawParam) { |
| 264 | OS << " (param"; |
| 265 | SawParam = true; |
| 266 | } |
| 267 | OS << ' ' << toString(VT.getSimpleVT()); |
| 268 | } |
| 269 | } |
| 270 | if (SawParam) |
| 271 | OS << ')'; |
| 272 | |
| 273 | for (EVT VT : ResultVTs) |
| 274 | OS << " (result " << toString(VT.getSimpleVT()) << ')'; |
| 275 | |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 276 | OS << '\n'; |
JF Bastien | 5789a69 | 2015-10-30 16:41:21 +0000 | [diff] [blame] | 277 | } |
Dan Gohman | 754cd11 | 2015-11-11 01:33:02 +0000 | [diff] [blame] | 278 | |
| 279 | StringRef Text = OS.str(); |
| 280 | if (!Text.empty()) |
| 281 | OutStreamer->EmitRawText(Text.substr(0, Text.size() - 1)); |
JF Bastien | 1a59c6b | 2015-10-21 02:23:09 +0000 | [diff] [blame] | 282 | } |
| 283 | |
Dan Gohman | f19ed56 | 2015-11-13 01:42:29 +0000 | [diff] [blame^] | 284 | bool WebAssemblyAsmPrinter::PrintAsmOperand(const MachineInstr *MI, |
| 285 | unsigned OpNo, unsigned AsmVariant, |
| 286 | const char *ExtraCode, |
| 287 | raw_ostream &OS) { |
| 288 | if (AsmVariant != 0) |
| 289 | report_fatal_error("There are no defined alternate asm variants"); |
| 290 | |
| 291 | if (!ExtraCode) { |
| 292 | const MachineOperand &MO = MI->getOperand(OpNo); |
| 293 | if (MO.isImm()) |
| 294 | OS << MO.getImm(); |
| 295 | else |
| 296 | OS << regToString(MO); |
| 297 | return false; |
| 298 | } |
| 299 | |
| 300 | return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, OS); |
| 301 | } |
| 302 | |
| 303 | bool WebAssemblyAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, |
| 304 | unsigned OpNo, |
| 305 | unsigned AsmVariant, |
| 306 | const char *ExtraCode, |
| 307 | raw_ostream &OS) { |
| 308 | if (AsmVariant != 0) |
| 309 | report_fatal_error("There are no defined alternate asm variants"); |
| 310 | |
| 311 | if (!ExtraCode) { |
| 312 | OS << regToString(MI->getOperand(OpNo)); |
| 313 | return false; |
| 314 | } |
| 315 | |
| 316 | return AsmPrinter::PrintAsmMemoryOperand(MI, OpNo, AsmVariant, ExtraCode, OS); |
| 317 | } |
| 318 | |
JF Bastien | b9073fb | 2015-07-22 21:28:15 +0000 | [diff] [blame] | 319 | // Force static initialization. |
| 320 | extern "C" void LLVMInitializeWebAssemblyAsmPrinter() { |
| 321 | RegisterAsmPrinter<WebAssemblyAsmPrinter> X(TheWebAssemblyTarget32); |
| 322 | RegisterAsmPrinter<WebAssemblyAsmPrinter> Y(TheWebAssemblyTarget64); |
| 323 | } |