| 1 | //===-- VEAsmPrinter.cpp - VE LLVM assembly writer ------------------------===// |
| 2 | // |
| 3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| 4 | // See https://llvm.org/LICENSE.txt for license information. |
| 5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 6 | // |
| 7 | //===----------------------------------------------------------------------===// |
| 8 | // |
| 9 | // This file contains a printer that converts from our internal representation |
| 10 | // of machine-dependent LLVM code to GAS-format VE assembly language. |
| 11 | // |
| 12 | //===----------------------------------------------------------------------===// |
| 13 | |
| 14 | #include "VEAsmPrinter.h" |
| 15 | #include "MCTargetDesc/VEInstPrinter.h" |
| 16 | #include "MCTargetDesc/VEMCAsmInfo.h" |
| 17 | #include "MCTargetDesc/VETargetStreamer.h" |
| 18 | #include "TargetInfo/VETargetInfo.h" |
| 19 | #include "VE.h" |
| 20 | #include "VEInstrInfo.h" |
| 21 | #include "llvm/CodeGen/AsmPrinter.h" |
| 22 | #include "llvm/CodeGen/AsmPrinterAnalysis.h" |
| 23 | #include "llvm/CodeGen/MachineInstr.h" |
| 24 | #include "llvm/CodeGen/MachineModuleInfoImpls.h" |
| 25 | #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h" |
| 26 | #include "llvm/IR/Mangler.h" |
| 27 | #include "llvm/MC/MCAsmInfo.h" |
| 28 | #include "llvm/MC/MCContext.h" |
| 29 | #include "llvm/MC/MCInst.h" |
| 30 | #include "llvm/MC/MCStreamer.h" |
| 31 | #include "llvm/MC/MCSymbol.h" |
| 32 | #include "llvm/MC/TargetRegistry.h" |
| 33 | #include "llvm/Support/Compiler.h" |
| 34 | #include "llvm/Support/raw_ostream.h" |
| 35 | using namespace llvm; |
| 36 | |
| 37 | #define DEBUG_TYPE "ve-asmprinter" |
| 38 | |
| 39 | namespace { |
| 40 | class VEAsmPrinter : public AsmPrinter { |
| 41 | VETargetStreamer &getTargetStreamer() { |
| 42 | return static_cast<VETargetStreamer &>(*OutStreamer->getTargetStreamer()); |
| 43 | } |
| 44 | |
| 45 | public: |
| 46 | explicit VEAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer) |
| 47 | : AsmPrinter(TM, std::move(Streamer), ID) {} |
| 48 | |
| 49 | StringRef getPassName() const override { return "VE Assembly Printer" ; } |
| 50 | |
| 51 | void lowerGETGOTAndEmitMCInsts(const MachineInstr *MI, |
| 52 | const MCSubtargetInfo &STI); |
| 53 | void lowerGETFunPLTAndEmitMCInsts(const MachineInstr *MI, |
| 54 | const MCSubtargetInfo &STI); |
| 55 | void lowerGETTLSAddrAndEmitMCInsts(const MachineInstr *MI, |
| 56 | const MCSubtargetInfo &STI); |
| 57 | |
| 58 | void emitInstruction(const MachineInstr *MI) override; |
| 59 | |
| 60 | static const char *getRegisterName(MCRegister Reg) { |
| 61 | return VEInstPrinter::getRegisterName(Reg); |
| 62 | } |
| 63 | void printOperand(const MachineInstr *MI, int OpNum, raw_ostream &OS); |
| 64 | bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
| 65 | const char *, raw_ostream &O) override; |
| 66 | bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
| 67 | const char *, raw_ostream &O) override; |
| 68 | |
| 69 | static char ID; |
| 70 | }; |
| 71 | } // end of anonymous namespace |
| 72 | |
| 73 | static MCOperand createVEMCOperand(VE::Specifier Kind, MCSymbol *Sym, |
| 74 | MCContext &OutContext) { |
| 75 | const MCSymbolRefExpr *MCSym = MCSymbolRefExpr::create(Symbol: Sym, Ctx&: OutContext); |
| 76 | return MCOperand::createExpr( |
| 77 | Val: MCSpecifierExpr::create(Expr: MCSym, S: Kind, Ctx&: OutContext)); |
| 78 | } |
| 79 | |
| 80 | static MCOperand createGOTRelExprOp(VE::Specifier Kind, MCSymbol *GOTLabel, |
| 81 | MCContext &OutContext) { |
| 82 | const MCSymbolRefExpr *GOT = MCSymbolRefExpr::create(Symbol: GOTLabel, Ctx&: OutContext); |
| 83 | return MCOperand::createExpr(Val: MCSpecifierExpr::create(Expr: GOT, S: Kind, Ctx&: OutContext)); |
| 84 | } |
| 85 | |
| 86 | static void emitSIC(MCStreamer &OutStreamer, MCOperand &RD, |
| 87 | const MCSubtargetInfo &STI) { |
| 88 | MCInst SICInst; |
| 89 | SICInst.setOpcode(VE::SIC); |
| 90 | SICInst.addOperand(Op: RD); |
| 91 | OutStreamer.emitInstruction(Inst: SICInst, STI); |
| 92 | } |
| 93 | |
| 94 | static void emitBSIC(MCStreamer &OutStreamer, MCOperand &R1, MCOperand &R2, |
| 95 | const MCSubtargetInfo &STI) { |
| 96 | MCInst BSICInst; |
| 97 | BSICInst.setOpcode(VE::BSICrii); |
| 98 | BSICInst.addOperand(Op: R1); |
| 99 | BSICInst.addOperand(Op: R2); |
| 100 | MCOperand czero = MCOperand::createImm(Val: 0); |
| 101 | BSICInst.addOperand(Op: czero); |
| 102 | BSICInst.addOperand(Op: czero); |
| 103 | OutStreamer.emitInstruction(Inst: BSICInst, STI); |
| 104 | } |
| 105 | |
| 106 | static void emitLEAzzi(MCStreamer &OutStreamer, MCOperand &Imm, MCOperand &RD, |
| 107 | const MCSubtargetInfo &STI) { |
| 108 | MCInst LEAInst; |
| 109 | LEAInst.setOpcode(VE::LEAzii); |
| 110 | LEAInst.addOperand(Op: RD); |
| 111 | MCOperand CZero = MCOperand::createImm(Val: 0); |
| 112 | LEAInst.addOperand(Op: CZero); |
| 113 | LEAInst.addOperand(Op: CZero); |
| 114 | LEAInst.addOperand(Op: Imm); |
| 115 | OutStreamer.emitInstruction(Inst: LEAInst, STI); |
| 116 | } |
| 117 | |
| 118 | static void emitLEASLzzi(MCStreamer &OutStreamer, MCOperand &Imm, MCOperand &RD, |
| 119 | const MCSubtargetInfo &STI) { |
| 120 | MCInst LEASLInst; |
| 121 | LEASLInst.setOpcode(VE::LEASLzii); |
| 122 | LEASLInst.addOperand(Op: RD); |
| 123 | MCOperand CZero = MCOperand::createImm(Val: 0); |
| 124 | LEASLInst.addOperand(Op: CZero); |
| 125 | LEASLInst.addOperand(Op: CZero); |
| 126 | LEASLInst.addOperand(Op: Imm); |
| 127 | OutStreamer.emitInstruction(Inst: LEASLInst, STI); |
| 128 | } |
| 129 | |
| 130 | static void emitLEAzii(MCStreamer &OutStreamer, MCOperand &RS1, MCOperand &Imm, |
| 131 | MCOperand &RD, const MCSubtargetInfo &STI) { |
| 132 | MCInst LEAInst; |
| 133 | LEAInst.setOpcode(VE::LEAzii); |
| 134 | LEAInst.addOperand(Op: RD); |
| 135 | MCOperand CZero = MCOperand::createImm(Val: 0); |
| 136 | LEAInst.addOperand(Op: CZero); |
| 137 | LEAInst.addOperand(Op: RS1); |
| 138 | LEAInst.addOperand(Op: Imm); |
| 139 | OutStreamer.emitInstruction(Inst: LEAInst, STI); |
| 140 | } |
| 141 | |
| 142 | static void emitLEASLrri(MCStreamer &OutStreamer, MCOperand &RS1, |
| 143 | MCOperand &RS2, MCOperand &Imm, MCOperand &RD, |
| 144 | const MCSubtargetInfo &STI) { |
| 145 | MCInst LEASLInst; |
| 146 | LEASLInst.setOpcode(VE::LEASLrri); |
| 147 | LEASLInst.addOperand(Op: RD); |
| 148 | LEASLInst.addOperand(Op: RS1); |
| 149 | LEASLInst.addOperand(Op: RS2); |
| 150 | LEASLInst.addOperand(Op: Imm); |
| 151 | OutStreamer.emitInstruction(Inst: LEASLInst, STI); |
| 152 | } |
| 153 | |
| 154 | static void emitBinary(MCStreamer &OutStreamer, unsigned Opcode, MCOperand &RS1, |
| 155 | MCOperand &Src2, MCOperand &RD, |
| 156 | const MCSubtargetInfo &STI) { |
| 157 | MCInst Inst; |
| 158 | Inst.setOpcode(Opcode); |
| 159 | Inst.addOperand(Op: RD); |
| 160 | Inst.addOperand(Op: RS1); |
| 161 | Inst.addOperand(Op: Src2); |
| 162 | OutStreamer.emitInstruction(Inst, STI); |
| 163 | } |
| 164 | |
| 165 | static void emitANDrm(MCStreamer &OutStreamer, MCOperand &RS1, MCOperand &Imm, |
| 166 | MCOperand &RD, const MCSubtargetInfo &STI) { |
| 167 | emitBinary(OutStreamer, Opcode: VE::ANDrm, RS1, Src2&: Imm, RD, STI); |
| 168 | } |
| 169 | |
| 170 | static void emitHiLo(MCStreamer &OutStreamer, MCSymbol *GOTSym, |
| 171 | VE::Specifier HiKind, VE::Specifier LoKind, MCOperand &RD, |
| 172 | MCContext &OutContext, const MCSubtargetInfo &STI) { |
| 173 | |
| 174 | MCOperand hi = createVEMCOperand(Kind: HiKind, Sym: GOTSym, OutContext); |
| 175 | MCOperand lo = createVEMCOperand(Kind: LoKind, Sym: GOTSym, OutContext); |
| 176 | emitLEAzzi(OutStreamer, Imm&: lo, RD, STI); |
| 177 | MCOperand M032 = MCOperand::createImm(Val: M0(Val: 32)); |
| 178 | emitANDrm(OutStreamer, RS1&: RD, Imm&: M032, RD, STI); |
| 179 | emitLEASLzzi(OutStreamer, Imm&: hi, RD, STI); |
| 180 | } |
| 181 | |
| 182 | void VEAsmPrinter::lowerGETGOTAndEmitMCInsts(const MachineInstr *MI, |
| 183 | const MCSubtargetInfo &STI) { |
| 184 | MCSymbol *GOTLabel = |
| 185 | OutContext.getOrCreateSymbol(Name: Twine("_GLOBAL_OFFSET_TABLE_" )); |
| 186 | |
| 187 | const MachineOperand &MO = MI->getOperand(i: 0); |
| 188 | MCOperand MCRegOP = MCOperand::createReg(Reg: MO.getReg()); |
| 189 | |
| 190 | if (!isPositionIndependent()) { |
| 191 | // Just load the address of GOT to MCRegOP. |
| 192 | switch (TM.getCodeModel()) { |
| 193 | default: |
| 194 | llvm_unreachable("Unsupported absolute code model" ); |
| 195 | case CodeModel::Small: |
| 196 | case CodeModel::Medium: |
| 197 | case CodeModel::Large: |
| 198 | emitHiLo(OutStreamer&: *OutStreamer, GOTSym: GOTLabel, HiKind: VE::S_HI32, LoKind: VE::S_LO32, RD&: MCRegOP, |
| 199 | OutContext, STI); |
| 200 | break; |
| 201 | } |
| 202 | return; |
| 203 | } |
| 204 | |
| 205 | MCOperand RegGOT = MCOperand::createReg(Reg: VE::SX15); // GOT |
| 206 | MCOperand RegPLT = MCOperand::createReg(Reg: VE::SX16); // PLT |
| 207 | |
| 208 | // lea %got, _GLOBAL_OFFSET_TABLE_@PC_LO(-24) |
| 209 | // and %got, %got, (32)0 |
| 210 | // sic %plt |
| 211 | // lea.sl %got, _GLOBAL_OFFSET_TABLE_@PC_HI(%plt, %got) |
| 212 | MCOperand cim24 = MCOperand::createImm(Val: -24); |
| 213 | MCOperand loImm = createGOTRelExprOp(Kind: VE::S_PC_LO32, GOTLabel, OutContext); |
| 214 | emitLEAzii(OutStreamer&: *OutStreamer, RS1&: cim24, Imm&: loImm, RD&: MCRegOP, STI); |
| 215 | MCOperand M032 = MCOperand::createImm(Val: M0(Val: 32)); |
| 216 | emitANDrm(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: M032, RD&: MCRegOP, STI); |
| 217 | emitSIC(OutStreamer&: *OutStreamer, RD&: RegPLT, STI); |
| 218 | MCOperand hiImm = createGOTRelExprOp(Kind: VE::S_PC_HI32, GOTLabel, OutContext); |
| 219 | emitLEASLrri(OutStreamer&: *OutStreamer, RS1&: RegGOT, RS2&: RegPLT, Imm&: hiImm, RD&: MCRegOP, STI); |
| 220 | } |
| 221 | |
| 222 | void VEAsmPrinter::lowerGETFunPLTAndEmitMCInsts(const MachineInstr *MI, |
| 223 | const MCSubtargetInfo &STI) { |
| 224 | const MachineOperand &MO = MI->getOperand(i: 0); |
| 225 | MCOperand MCRegOP = MCOperand::createReg(Reg: MO.getReg()); |
| 226 | const MachineOperand &Addr = MI->getOperand(i: 1); |
| 227 | MCSymbol *AddrSym = nullptr; |
| 228 | |
| 229 | switch (Addr.getType()) { |
| 230 | default: |
| 231 | llvm_unreachable("<unknown operand type>" ); |
| 232 | return; |
| 233 | case MachineOperand::MO_MachineBasicBlock: |
| 234 | report_fatal_error(reason: "MBB is not supported yet" ); |
| 235 | return; |
| 236 | case MachineOperand::MO_ConstantPoolIndex: |
| 237 | report_fatal_error(reason: "ConstantPool is not supported yet" ); |
| 238 | return; |
| 239 | case MachineOperand::MO_ExternalSymbol: |
| 240 | AddrSym = GetExternalSymbolSymbol(Sym: Addr.getSymbolName()); |
| 241 | break; |
| 242 | case MachineOperand::MO_GlobalAddress: |
| 243 | AddrSym = getSymbol(GV: Addr.getGlobal()); |
| 244 | break; |
| 245 | } |
| 246 | |
| 247 | if (!isPositionIndependent()) { |
| 248 | llvm_unreachable("Unsupported uses of %plt in not PIC code" ); |
| 249 | return; |
| 250 | } |
| 251 | |
| 252 | MCOperand RegPLT = MCOperand::createReg(Reg: VE::SX16); // PLT |
| 253 | |
| 254 | // lea %dst, func@plt_lo(-24) |
| 255 | // and %dst, %dst, (32)0 |
| 256 | // sic %plt ; FIXME: is it safe to use %plt here? |
| 257 | // lea.sl %dst, func@plt_hi(%plt, %dst) |
| 258 | MCOperand cim24 = MCOperand::createImm(Val: -24); |
| 259 | MCOperand loImm = createGOTRelExprOp(Kind: VE::S_PLT_LO32, GOTLabel: AddrSym, OutContext); |
| 260 | emitLEAzii(OutStreamer&: *OutStreamer, RS1&: cim24, Imm&: loImm, RD&: MCRegOP, STI); |
| 261 | MCOperand M032 = MCOperand::createImm(Val: M0(Val: 32)); |
| 262 | emitANDrm(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: M032, RD&: MCRegOP, STI); |
| 263 | emitSIC(OutStreamer&: *OutStreamer, RD&: RegPLT, STI); |
| 264 | MCOperand hiImm = createGOTRelExprOp(Kind: VE::S_PLT_HI32, GOTLabel: AddrSym, OutContext); |
| 265 | emitLEASLrri(OutStreamer&: *OutStreamer, RS1&: MCRegOP, RS2&: RegPLT, Imm&: hiImm, RD&: MCRegOP, STI); |
| 266 | } |
| 267 | |
| 268 | void VEAsmPrinter::lowerGETTLSAddrAndEmitMCInsts(const MachineInstr *MI, |
| 269 | const MCSubtargetInfo &STI) { |
| 270 | const MachineOperand &Addr = MI->getOperand(i: 0); |
| 271 | MCSymbol *AddrSym = nullptr; |
| 272 | |
| 273 | switch (Addr.getType()) { |
| 274 | default: |
| 275 | llvm_unreachable("<unknown operand type>" ); |
| 276 | return; |
| 277 | case MachineOperand::MO_MachineBasicBlock: |
| 278 | report_fatal_error(reason: "MBB is not supported yet" ); |
| 279 | return; |
| 280 | case MachineOperand::MO_ConstantPoolIndex: |
| 281 | report_fatal_error(reason: "ConstantPool is not supported yet" ); |
| 282 | return; |
| 283 | case MachineOperand::MO_ExternalSymbol: |
| 284 | AddrSym = GetExternalSymbolSymbol(Sym: Addr.getSymbolName()); |
| 285 | break; |
| 286 | case MachineOperand::MO_GlobalAddress: |
| 287 | AddrSym = getSymbol(GV: Addr.getGlobal()); |
| 288 | break; |
| 289 | } |
| 290 | |
| 291 | MCOperand RegLR = MCOperand::createReg(Reg: VE::SX10); // LR |
| 292 | MCOperand RegS0 = MCOperand::createReg(Reg: VE::SX0); // S0 |
| 293 | MCOperand RegS12 = MCOperand::createReg(Reg: VE::SX12); // S12 |
| 294 | MCSymbol *GetTLSLabel = OutContext.getOrCreateSymbol(Name: Twine("__tls_get_addr" )); |
| 295 | |
| 296 | // lea %s0, sym@tls_gd_lo(-24) |
| 297 | // and %s0, %s0, (32)0 |
| 298 | // sic %lr |
| 299 | // lea.sl %s0, sym@tls_gd_hi(%lr, %s0) |
| 300 | // lea %s12, __tls_get_addr@plt_lo(8) |
| 301 | // and %s12, %s12, (32)0 |
| 302 | // lea.sl %s12, __tls_get_addr@plt_hi(%s12, %lr) |
| 303 | // bsic %lr, (, %s12) |
| 304 | MCOperand cim24 = MCOperand::createImm(Val: -24); |
| 305 | MCOperand loImm = createGOTRelExprOp(Kind: VE::S_TLS_GD_LO32, GOTLabel: AddrSym, OutContext); |
| 306 | emitLEAzii(OutStreamer&: *OutStreamer, RS1&: cim24, Imm&: loImm, RD&: RegS0, STI); |
| 307 | MCOperand M032 = MCOperand::createImm(Val: M0(Val: 32)); |
| 308 | emitANDrm(OutStreamer&: *OutStreamer, RS1&: RegS0, Imm&: M032, RD&: RegS0, STI); |
| 309 | emitSIC(OutStreamer&: *OutStreamer, RD&: RegLR, STI); |
| 310 | MCOperand hiImm = createGOTRelExprOp(Kind: VE::S_TLS_GD_HI32, GOTLabel: AddrSym, OutContext); |
| 311 | emitLEASLrri(OutStreamer&: *OutStreamer, RS1&: RegS0, RS2&: RegLR, Imm&: hiImm, RD&: RegS0, STI); |
| 312 | MCOperand ci8 = MCOperand::createImm(Val: 8); |
| 313 | MCOperand loImm2 = |
| 314 | createGOTRelExprOp(Kind: VE::S_PLT_LO32, GOTLabel: GetTLSLabel, OutContext); |
| 315 | emitLEAzii(OutStreamer&: *OutStreamer, RS1&: ci8, Imm&: loImm2, RD&: RegS12, STI); |
| 316 | emitANDrm(OutStreamer&: *OutStreamer, RS1&: RegS12, Imm&: M032, RD&: RegS12, STI); |
| 317 | MCOperand hiImm2 = |
| 318 | createGOTRelExprOp(Kind: VE::S_PLT_HI32, GOTLabel: GetTLSLabel, OutContext); |
| 319 | emitLEASLrri(OutStreamer&: *OutStreamer, RS1&: RegS12, RS2&: RegLR, Imm&: hiImm2, RD&: RegS12, STI); |
| 320 | emitBSIC(OutStreamer&: *OutStreamer, R1&: RegLR, R2&: RegS12, STI); |
| 321 | } |
| 322 | |
| 323 | void VEAsmPrinter::emitInstruction(const MachineInstr *MI) { |
| 324 | VE_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(), |
| 325 | Features: getSubtargetInfo().getFeatureBits()); |
| 326 | |
| 327 | switch (MI->getOpcode()) { |
| 328 | default: |
| 329 | break; |
| 330 | case TargetOpcode::DBG_VALUE: |
| 331 | // FIXME: Debug Value. |
| 332 | return; |
| 333 | case VE::GETGOT: |
| 334 | lowerGETGOTAndEmitMCInsts(MI, STI: getSubtargetInfo()); |
| 335 | return; |
| 336 | case VE::GETFUNPLT: |
| 337 | lowerGETFunPLTAndEmitMCInsts(MI, STI: getSubtargetInfo()); |
| 338 | return; |
| 339 | case VE::GETTLSADDR: |
| 340 | lowerGETTLSAddrAndEmitMCInsts(MI, STI: getSubtargetInfo()); |
| 341 | return; |
| 342 | } |
| 343 | |
| 344 | MachineBasicBlock::const_instr_iterator I = MI->getIterator(); |
| 345 | MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end(); |
| 346 | do { |
| 347 | MCInst TmpInst; |
| 348 | LowerVEMachineInstrToMCInst(MI: &*I, OutMI&: TmpInst, AP&: *this); |
| 349 | EmitToStreamer(S&: *OutStreamer, Inst: TmpInst); |
| 350 | } while ((++I != E) && I->isInsideBundle()); // Delay slot check. |
| 351 | } |
| 352 | |
| 353 | void VEAsmPrinter::printOperand(const MachineInstr *MI, int OpNum, |
| 354 | raw_ostream &O) { |
| 355 | const MachineOperand &MO = MI->getOperand(i: OpNum); |
| 356 | |
| 357 | switch (MO.getType()) { |
| 358 | case MachineOperand::MO_Register: |
| 359 | O << "%" << StringRef(getRegisterName(Reg: MO.getReg())).lower(); |
| 360 | break; |
| 361 | case MachineOperand::MO_Immediate: |
| 362 | O << (int)MO.getImm(); |
| 363 | break; |
| 364 | default: |
| 365 | llvm_unreachable("<unknown operand type>" ); |
| 366 | } |
| 367 | } |
| 368 | |
| 369 | // PrintAsmOperand - Print out an operand for an inline asm expression. |
| 370 | bool VEAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, |
| 371 | const char *, raw_ostream &O) { |
| 372 | if (ExtraCode && ExtraCode[0]) { |
| 373 | if (ExtraCode[1] != 0) |
| 374 | return true; // Unknown modifier. |
| 375 | |
| 376 | switch (ExtraCode[0]) { |
| 377 | default: |
| 378 | // See if this is a generic print operand |
| 379 | return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS&: O); |
| 380 | case 'r': |
| 381 | case 'v': |
| 382 | break; |
| 383 | } |
| 384 | } |
| 385 | |
| 386 | printOperand(MI, OpNum: OpNo, O); |
| 387 | |
| 388 | return false; |
| 389 | } |
| 390 | |
| 391 | bool VEAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo, |
| 392 | const char *, |
| 393 | raw_ostream &O) { |
| 394 | if (ExtraCode && ExtraCode[0]) |
| 395 | return true; // Unknown modifier |
| 396 | |
| 397 | if (MI->getOperand(i: OpNo+1).isImm() && |
| 398 | MI->getOperand(i: OpNo+1).getImm() == 0) { |
| 399 | // don't print "+0" |
| 400 | } else { |
| 401 | printOperand(MI, OpNum: OpNo+1, O); |
| 402 | } |
| 403 | if (MI->getOperand(i: OpNo).isImm() && |
| 404 | MI->getOperand(i: OpNo).getImm() == 0) { |
| 405 | if (MI->getOperand(i: OpNo+1).isImm() && |
| 406 | MI->getOperand(i: OpNo+1).getImm() == 0) { |
| 407 | O << "0" ; |
| 408 | } else { |
| 409 | // don't print "(0)" |
| 410 | } |
| 411 | } else { |
| 412 | O << "(" ; |
| 413 | printOperand(MI, OpNum: OpNo, O); |
| 414 | O << ")" ; |
| 415 | } |
| 416 | return false; |
| 417 | } |
| 418 | |
| 419 | char VEAsmPrinter::ID = 0; |
| 420 | |
| 421 | INITIALIZE_PASS(VEAsmPrinter, "ve-asm-printer" , "VE Assembly Printer" , false, |
| 422 | false) |
| 423 | |
| 424 | // Force static initialization. |
| 425 | extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeVEAsmPrinter() { |
| 426 | RegisterAsmPrinter<VEAsmPrinter> X(getTheVETarget()); |
| 427 | } |
| 428 | |
| 429 | PreservedAnalyses VEAsmPrinterBeginPass::run(Module &M, |
| 430 | ModuleAnalysisManager &MAM) { |
| 431 | VEAsmPrinter &AsmPrinter = static_cast<VEAsmPrinter &>( |
| 432 | MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter()); |
| 433 | setupModuleAsmPrinter(M, MAM, AsmPrinter); |
| 434 | AsmPrinter.doInitialization(M); |
| 435 | return PreservedAnalyses::all(); |
| 436 | } |
| 437 | |
| 438 | PreservedAnalyses VEAsmPrinterPass::run(MachineFunction &MF, |
| 439 | MachineFunctionAnalysisManager &MFAM) { |
| 440 | VEAsmPrinter &AsmPrinter = static_cast<VEAsmPrinter &>( |
| 441 | MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(IR&: MF) |
| 442 | .getCachedResult<AsmPrinterAnalysis>(IR&: *MF.getFunction().getParent()) |
| 443 | ->getPrinter()); |
| 444 | setupMachineFunctionAsmPrinter(MFAM, MF, AsmPrinter); |
| 445 | AsmPrinter.runOnMachineFunction(MF); |
| 446 | return PreservedAnalyses::all(); |
| 447 | } |
| 448 | |
| 449 | PreservedAnalyses VEAsmPrinterEndPass::run(Module &M, |
| 450 | ModuleAnalysisManager &MAM) { |
| 451 | VEAsmPrinter &AsmPrinter = static_cast<VEAsmPrinter &>( |
| 452 | MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter()); |
| 453 | setupModuleAsmPrinter(M, MAM, AsmPrinter); |
| 454 | AsmPrinter.doFinalization(M); |
| 455 | return PreservedAnalyses::all(); |
| 456 | } |
| 457 | |