1//===-- SparcAsmPrinter.cpp - Sparc 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 SPARC assembly language.
11//
12//===----------------------------------------------------------------------===//
13
14#include "SparcAsmPrinter.h"
15#include "MCTargetDesc/SparcInstPrinter.h"
16#include "MCTargetDesc/SparcMCAsmInfo.h"
17#include "MCTargetDesc/SparcMCTargetDesc.h"
18#include "MCTargetDesc/SparcTargetStreamer.h"
19#include "Sparc.h"
20#include "SparcInstrInfo.h"
21#include "SparcTargetMachine.h"
22#include "TargetInfo/SparcTargetInfo.h"
23#include "llvm/BinaryFormat/ELF.h"
24#include "llvm/CodeGen/AsmPrinter.h"
25#include "llvm/CodeGen/AsmPrinterAnalysis.h"
26#include "llvm/CodeGen/MachineInstr.h"
27#include "llvm/CodeGen/MachineModuleInfoImpls.h"
28#include "llvm/CodeGen/MachineRegisterInfo.h"
29#include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
30#include "llvm/IR/Mangler.h"
31#include "llvm/MC/MCAsmInfo.h"
32#include "llvm/MC/MCContext.h"
33#include "llvm/MC/MCInst.h"
34#include "llvm/MC/MCStreamer.h"
35#include "llvm/MC/MCSymbol.h"
36#include "llvm/MC/TargetRegistry.h"
37#include "llvm/Support/Compiler.h"
38#include "llvm/Support/raw_ostream.h"
39using namespace llvm;
40
41#define DEBUG_TYPE "asm-printer"
42
43namespace {
44class SparcAsmPrinter : public AsmPrinter {
45 SparcTargetStreamer &getTargetStreamer() {
46 return static_cast<SparcTargetStreamer &>(
47 *OutStreamer->getTargetStreamer());
48 }
49
50public:
51 explicit SparcAsmPrinter(TargetMachine &TM,
52 std::unique_ptr<MCStreamer> Streamer)
53 : AsmPrinter(TM, std::move(Streamer), ID) {}
54
55 StringRef getPassName() const override { return "Sparc Assembly Printer"; }
56
57 void printOperand(const MachineInstr *MI, int opNum, raw_ostream &OS);
58 void printMemOperand(const MachineInstr *MI, int opNum, raw_ostream &OS);
59
60 void emitFunctionBodyStart() override;
61 void emitInstruction(const MachineInstr *MI) override;
62
63 static const char *getRegisterName(MCRegister Reg) {
64 return SparcInstPrinter::getRegisterName(Reg);
65 }
66
67 bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
68 const char *ExtraCode, raw_ostream &O) override;
69 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
70 const char *ExtraCode, raw_ostream &O) override;
71 void PrintSymbolOperand(const MachineOperand &MO, raw_ostream &O) override;
72
73 void LowerGETPCXAndEmitMCInsts(const MachineInstr *MI,
74 const MCSubtargetInfo &STI);
75
76 MCOperand lowerOperand(const MachineOperand &MO) const;
77
78private:
79 void lowerToMCInst(const MachineInstr *MI, MCInst &OutMI);
80
81public:
82 static char ID;
83};
84} // end of anonymous namespace
85
86static MCOperand createSparcMCOperand(uint16_t Kind, MCSymbol *Sym,
87 MCContext &OutContext) {
88 const MCSymbolRefExpr *MCSym = MCSymbolRefExpr::create(Symbol: Sym, Ctx&: OutContext);
89 auto *expr = MCSpecifierExpr::create(Expr: MCSym, S: Kind, Ctx&: OutContext);
90 return MCOperand::createExpr(Val: expr);
91}
92static MCOperand createPCXCallOP(MCSymbol *Label,
93 MCContext &OutContext) {
94 return MCOperand::createExpr(Val: MCSymbolRefExpr::create(Symbol: Label, Ctx&: OutContext));
95}
96
97static MCOperand createPCXRelExprOp(uint16_t Spec, MCSymbol *GOTLabel,
98 MCSymbol *StartLabel, MCSymbol *CurLabel,
99 MCContext &OutContext) {
100 const MCSymbolRefExpr *GOT = MCSymbolRefExpr::create(Symbol: GOTLabel, Ctx&: OutContext);
101 const MCSymbolRefExpr *Start = MCSymbolRefExpr::create(Symbol: StartLabel,
102 Ctx&: OutContext);
103 const MCSymbolRefExpr *Cur = MCSymbolRefExpr::create(Symbol: CurLabel,
104 Ctx&: OutContext);
105
106 const MCBinaryExpr *Sub = MCBinaryExpr::createSub(LHS: Cur, RHS: Start, Ctx&: OutContext);
107 const MCBinaryExpr *Add = MCBinaryExpr::createAdd(LHS: GOT, RHS: Sub, Ctx&: OutContext);
108 auto *expr = MCSpecifierExpr::create(Expr: Add, S: Spec, Ctx&: OutContext);
109 return MCOperand::createExpr(Val: expr);
110}
111
112static void EmitCall(MCStreamer &OutStreamer,
113 MCOperand &Callee,
114 const MCSubtargetInfo &STI)
115{
116 MCInst CallInst;
117 CallInst.setOpcode(SP::CALL);
118 CallInst.addOperand(Op: Callee);
119 OutStreamer.emitInstruction(Inst: CallInst, STI);
120}
121
122static void EmitRDPC(MCStreamer &OutStreamer, MCOperand &RD,
123 const MCSubtargetInfo &STI) {
124 MCInst RDPCInst;
125 RDPCInst.setOpcode(SP::RDASR);
126 RDPCInst.addOperand(Op: RD);
127 RDPCInst.addOperand(Op: MCOperand::createReg(Reg: SP::ASR5));
128 OutStreamer.emitInstruction(Inst: RDPCInst, STI);
129}
130
131static void EmitSETHI(MCStreamer &OutStreamer,
132 MCOperand &Imm, MCOperand &RD,
133 const MCSubtargetInfo &STI)
134{
135 MCInst SETHIInst;
136 SETHIInst.setOpcode(SP::SETHIi);
137 SETHIInst.addOperand(Op: RD);
138 SETHIInst.addOperand(Op: Imm);
139 OutStreamer.emitInstruction(Inst: SETHIInst, STI);
140}
141
142static void EmitBinary(MCStreamer &OutStreamer, unsigned Opcode,
143 MCOperand &RS1, MCOperand &Src2, MCOperand &RD,
144 const MCSubtargetInfo &STI)
145{
146 MCInst Inst;
147 Inst.setOpcode(Opcode);
148 Inst.addOperand(Op: RD);
149 Inst.addOperand(Op: RS1);
150 Inst.addOperand(Op: Src2);
151 OutStreamer.emitInstruction(Inst, STI);
152}
153
154static void EmitOR(MCStreamer &OutStreamer,
155 MCOperand &RS1, MCOperand &Imm, MCOperand &RD,
156 const MCSubtargetInfo &STI) {
157 EmitBinary(OutStreamer, Opcode: SP::ORri, RS1, Src2&: Imm, RD, STI);
158}
159
160static void EmitADD(MCStreamer &OutStreamer,
161 MCOperand &RS1, MCOperand &RS2, MCOperand &RD,
162 const MCSubtargetInfo &STI) {
163 EmitBinary(OutStreamer, Opcode: SP::ADDrr, RS1, Src2&: RS2, RD, STI);
164}
165
166static void EmitSHL(MCStreamer &OutStreamer,
167 MCOperand &RS1, MCOperand &Imm, MCOperand &RD,
168 const MCSubtargetInfo &STI) {
169 EmitBinary(OutStreamer, Opcode: SP::SLLri, RS1, Src2&: Imm, RD, STI);
170}
171
172static void emitHiLo(MCStreamer &OutStreamer, MCSymbol *GOTSym, uint16_t HiKind,
173 uint16_t LoKind, MCOperand &RD, MCContext &OutContext,
174 const MCSubtargetInfo &STI) {
175 MCOperand hi = createSparcMCOperand(Kind: HiKind, Sym: GOTSym, OutContext);
176 MCOperand lo = createSparcMCOperand(Kind: LoKind, Sym: GOTSym, OutContext);
177 EmitSETHI(OutStreamer, Imm&: hi, RD, STI);
178 EmitOR(OutStreamer, RS1&: RD, Imm&: lo, RD, STI);
179}
180
181void SparcAsmPrinter::LowerGETPCXAndEmitMCInsts(const MachineInstr *MI,
182 const MCSubtargetInfo &STI)
183{
184 MCSymbol *GOTLabel =
185 OutContext.getOrCreateSymbol(Name: Twine("_GLOBAL_OFFSET_TABLE_"));
186
187 const MachineOperand &MO = MI->getOperand(i: 0);
188 assert(MO.getReg() != SP::O7 &&
189 "%o7 is assigned as destination for getpcx!");
190
191 MCOperand MCRegOP = MCOperand::createReg(Reg: MO.getReg());
192
193
194 if (!isPositionIndependent()) {
195 // Just load the address of GOT to MCRegOP.
196 switch(TM.getCodeModel()) {
197 default:
198 llvm_unreachable("Unsupported absolute code model");
199 case CodeModel::Small:
200 emitHiLo(OutStreamer&: *OutStreamer, GOTSym: GOTLabel, HiKind: ELF::R_SPARC_HI22, LoKind: ELF::R_SPARC_LO10,
201 RD&: MCRegOP, OutContext, STI);
202 break;
203 case CodeModel::Medium: {
204 emitHiLo(OutStreamer&: *OutStreamer, GOTSym: GOTLabel, HiKind: ELF::R_SPARC_H44, LoKind: ELF::R_SPARC_M44,
205 RD&: MCRegOP, OutContext, STI);
206 MCOperand imm = MCOperand::createExpr(Val: MCConstantExpr::create(Value: 12,
207 Ctx&: OutContext));
208 EmitSHL(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: imm, RD&: MCRegOP, STI);
209 MCOperand lo =
210 createSparcMCOperand(Kind: ELF::R_SPARC_L44, Sym: GOTLabel, OutContext);
211 EmitOR(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: lo, RD&: MCRegOP, STI);
212 break;
213 }
214 case CodeModel::Large: {
215 emitHiLo(OutStreamer&: *OutStreamer, GOTSym: GOTLabel, HiKind: ELF::R_SPARC_HH22, LoKind: ELF::R_SPARC_HM10,
216 RD&: MCRegOP, OutContext, STI);
217 MCOperand imm = MCOperand::createExpr(Val: MCConstantExpr::create(Value: 32,
218 Ctx&: OutContext));
219 EmitSHL(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: imm, RD&: MCRegOP, STI);
220 // Use register %o7 to load the lower 32 bits.
221 MCOperand RegO7 = MCOperand::createReg(Reg: SP::O7);
222 emitHiLo(OutStreamer&: *OutStreamer, GOTSym: GOTLabel, HiKind: ELF::R_SPARC_HI22, LoKind: ELF::R_SPARC_LO10,
223 RD&: RegO7, OutContext, STI);
224 EmitADD(OutStreamer&: *OutStreamer, RS1&: MCRegOP, RS2&: RegO7, RD&: MCRegOP, STI);
225 }
226 }
227 return;
228 }
229
230 MCSymbol *StartLabel = OutContext.createTempSymbol();
231 MCSymbol *EndLabel = OutContext.createTempSymbol();
232 MCSymbol *SethiLabel = OutContext.createTempSymbol();
233
234 MCOperand RegO7 = MCOperand::createReg(Reg: SP::O7);
235
236 // <StartLabel>:
237 // <GET-PC> // This will be either `call <EndLabel>` or `rd %pc, %o7`.
238 // <SethiLabel>:
239 // sethi %hi(_GLOBAL_OFFSET_TABLE_+(<SethiLabel>-<StartLabel>)), <MO>
240 // <EndLabel>:
241 // or <MO>, %lo(_GLOBAL_OFFSET_TABLE_+(<EndLabel>-<StartLabel>))), <MO>
242 // add <MO>, %o7, <MO>
243
244 OutStreamer->emitLabel(Symbol: StartLabel);
245 if (!STI.getTargetTriple().isSPARC64() ||
246 STI.hasFeature(Feature: Sparc::TuneSlowRDPC)) {
247 MCOperand Callee = createPCXCallOP(Label: EndLabel, OutContext);
248 EmitCall(OutStreamer&: *OutStreamer, Callee, STI);
249 } else {
250 // TODO find out whether it is possible to store PC
251 // in other registers, to enable leaf function optimization.
252 // (On the other hand, approx. over 97.8% of GETPCXes happen
253 // in non-leaf functions, so would this be worth the effort?)
254 EmitRDPC(OutStreamer&: *OutStreamer, RD&: RegO7, STI);
255 }
256 OutStreamer->emitLabel(Symbol: SethiLabel);
257 MCOperand hiImm = createPCXRelExprOp(Spec: ELF::R_SPARC_PC22, GOTLabel, StartLabel,
258 CurLabel: SethiLabel, OutContext);
259 EmitSETHI(OutStreamer&: *OutStreamer, Imm&: hiImm, RD&: MCRegOP, STI);
260 OutStreamer->emitLabel(Symbol: EndLabel);
261 MCOperand loImm = createPCXRelExprOp(Spec: ELF::R_SPARC_PC10, GOTLabel, StartLabel,
262 CurLabel: EndLabel, OutContext);
263 EmitOR(OutStreamer&: *OutStreamer, RS1&: MCRegOP, Imm&: loImm, RD&: MCRegOP, STI);
264 EmitADD(OutStreamer&: *OutStreamer, RS1&: MCRegOP, RS2&: RegO7, RD&: MCRegOP, STI);
265}
266
267MCOperand SparcAsmPrinter::lowerOperand(const MachineOperand &MO) const {
268 switch (MO.getType()) {
269 default:
270 llvm_unreachable("unknown operand type");
271 break;
272 case MachineOperand::MO_Register:
273 if (MO.isImplicit())
274 break;
275 return MCOperand::createReg(Reg: MO.getReg());
276
277 case MachineOperand::MO_Immediate:
278 return MCOperand::createImm(Val: MO.getImm());
279
280 case MachineOperand::MO_MachineBasicBlock:
281 case MachineOperand::MO_GlobalAddress:
282 case MachineOperand::MO_BlockAddress:
283 case MachineOperand::MO_ExternalSymbol:
284 case MachineOperand::MO_ConstantPoolIndex: {
285 auto RelType = MO.getTargetFlags();
286 const MCSymbol *Symbol = nullptr;
287 switch (MO.getType()) {
288 default:
289 llvm_unreachable("");
290 case MachineOperand::MO_MachineBasicBlock:
291 Symbol = MO.getMBB()->getSymbol();
292 break;
293 case MachineOperand::MO_GlobalAddress:
294 Symbol = getSymbol(GV: MO.getGlobal());
295 break;
296 case MachineOperand::MO_BlockAddress:
297 Symbol = GetBlockAddressSymbol(BA: MO.getBlockAddress());
298 break;
299 case MachineOperand::MO_ExternalSymbol:
300 Symbol = GetExternalSymbolSymbol(Sym: MO.getSymbolName());
301 break;
302 case MachineOperand::MO_ConstantPoolIndex:
303 Symbol = GetCPISymbol(CPID: MO.getIndex());
304 break;
305 }
306
307 const MCExpr *expr = MCSymbolRefExpr::create(Symbol, Ctx&: OutContext);
308 if (RelType)
309 expr = MCSpecifierExpr::create(Expr: expr, S: RelType, Ctx&: OutContext);
310 return MCOperand::createExpr(Val: expr);
311 }
312
313 case MachineOperand::MO_RegisterMask:
314 break;
315 }
316 return MCOperand();
317}
318
319void SparcAsmPrinter::lowerToMCInst(const MachineInstr *MI, MCInst &OutMI) {
320 OutMI.setOpcode(MI->getOpcode());
321
322 for (const MachineOperand &MO : MI->operands()) {
323 MCOperand MCOp = lowerOperand(MO);
324 if (MCOp.isValid())
325 OutMI.addOperand(Op: MCOp);
326 }
327}
328
329void SparcAsmPrinter::emitInstruction(const MachineInstr *MI) {
330 Sparc_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(),
331 Features: getSubtargetInfo().getFeatureBits());
332 if (MI->isBundle()) {
333 const MachineBasicBlock *MBB = MI->getParent();
334 MachineBasicBlock::const_instr_iterator I = ++MI->getIterator();
335 while (I != MBB->instr_end() && I->isInsideBundle()) {
336 emitInstruction(MI: &*I);
337 ++I;
338 }
339 return;
340 }
341
342 switch (MI->getOpcode()) {
343 default: break;
344 case TargetOpcode::DBG_VALUE:
345 // FIXME: Debug Value.
346 return;
347 case SP::CASArr:
348 case SP::SWAPrr:
349 case SP::SWAPri:
350 case SP::LDSTUBrr:
351 case SP::LDSTUBri:
352 case SP::LDSTUBArr:
353 if (MF->getSubtarget<SparcSubtarget>().fixTN0011())
354 OutStreamer->emitCodeAlignment(Alignment: Align(16), STI: getSubtargetInfo());
355 break;
356 case SP::GETPCX:
357 LowerGETPCXAndEmitMCInsts(MI, STI: getSubtargetInfo());
358 return;
359 }
360 MachineBasicBlock::const_instr_iterator I = MI->getIterator();
361 MachineBasicBlock::const_instr_iterator E = MI->getParent()->instr_end();
362 do {
363 MCInst TmpInst;
364 lowerToMCInst(MI: &*I, OutMI&: TmpInst);
365 EmitToStreamer(S&: *OutStreamer, Inst: TmpInst);
366 } while ((++I != E) && I->isInsideBundle()); // Delay slot check.
367}
368
369void SparcAsmPrinter::emitFunctionBodyStart() {
370 if (!MF->getSubtarget<SparcSubtarget>().is64Bit())
371 return;
372
373 const MachineRegisterInfo &MRI = MF->getRegInfo();
374 const unsigned globalRegs[] = { SP::G2, SP::G3, SP::G6, SP::G7, 0 };
375 for (unsigned i = 0; globalRegs[i] != 0; ++i) {
376 unsigned reg = globalRegs[i];
377 if (MRI.use_empty(RegNo: reg))
378 continue;
379
380 if (reg == SP::G6 || reg == SP::G7)
381 getTargetStreamer().emitSparcRegisterIgnore(reg);
382 else
383 getTargetStreamer().emitSparcRegisterScratch(reg);
384 }
385}
386
387void SparcAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
388 raw_ostream &O) {
389 const DataLayout &DL = getDataLayout();
390 const MachineOperand &MO = MI->getOperand(i: opNum);
391 switch (MO.getType()) {
392 case MachineOperand::MO_Register:
393 O << "%" << StringRef(getRegisterName(Reg: MO.getReg())).lower();
394 break;
395
396 case MachineOperand::MO_Immediate:
397 O << MO.getImm();
398 break;
399 case MachineOperand::MO_MachineBasicBlock:
400 MO.getMBB()->getSymbol()->print(OS&: O, MAI);
401 return;
402 case MachineOperand::MO_GlobalAddress:
403 PrintSymbolOperand(MO, O);
404 break;
405 case MachineOperand::MO_BlockAddress:
406 O << GetBlockAddressSymbol(BA: MO.getBlockAddress())->getName();
407 break;
408 case MachineOperand::MO_ExternalSymbol:
409 O << MO.getSymbolName();
410 break;
411 case MachineOperand::MO_ConstantPoolIndex:
412 O << DL.getInternalSymbolPrefix() << "CPI" << getFunctionNumber() << "_"
413 << MO.getIndex();
414 break;
415 case MachineOperand::MO_Metadata:
416 MO.getMetadata()->printAsOperand(OS&: O, M: MMI->getModule());
417 break;
418 default:
419 llvm_unreachable("<unknown operand type>");
420 }
421}
422
423void SparcAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
424 raw_ostream &O) {
425 const unsigned RelType = MO.getTargetFlags();
426 StringRef Specifier = Sparc::getSpecifierName(S: RelType);
427 if (!Specifier.empty())
428 O << '%' << Specifier << '(';
429 AsmPrinter::PrintSymbolOperand(MO, OS&: O);
430 if (!Specifier.empty())
431 O << ')';
432}
433
434void SparcAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum,
435 raw_ostream &O) {
436 printOperand(MI, opNum, O);
437
438 if (MI->getOperand(i: opNum+1).isReg() &&
439 MI->getOperand(i: opNum+1).getReg() == SP::G0)
440 return; // don't print "+%g0"
441 if (MI->getOperand(i: opNum+1).isImm() &&
442 MI->getOperand(i: opNum+1).getImm() == 0)
443 return; // don't print "+0"
444
445 O << "+";
446 printOperand(MI, opNum: opNum+1, O);
447}
448
449/// PrintAsmOperand - Print out an operand for an inline asm expression.
450///
451bool SparcAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
452 const char *ExtraCode,
453 raw_ostream &O) {
454 if (ExtraCode && ExtraCode[0]) {
455 if (ExtraCode[1] != 0) return true; // Unknown modifier.
456
457 switch (ExtraCode[0]) {
458 default:
459 // See if this is a generic print operand
460 return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS&: O);
461 case 'L': // Low order register of a twin word register operand
462 case 'H': // High order register of a twin word register operand
463 {
464 const SparcSubtarget &Subtarget = MF->getSubtarget<SparcSubtarget>();
465 const MachineOperand &MO = MI->getOperand(i: OpNo);
466 const SparcRegisterInfo *RegisterInfo = Subtarget.getRegisterInfo();
467 Register MOReg = MO.getReg();
468
469 Register HiReg, LoReg;
470 if (!SP::IntPairRegClass.contains(Reg: MOReg)) {
471 // If we aren't given a register pair already, find out which pair it
472 // belongs to. Note that here, the specified register operand, which
473 // refers to the high part of the twinword, needs to be an even-numbered
474 // register.
475 MOReg = RegisterInfo->getMatchingSuperReg(Reg: MOReg, SubIdx: SP::sub_even,
476 RC: &SP::IntPairRegClass);
477 if (!MOReg) {
478 SMLoc Loc;
479 OutContext.reportError(
480 L: Loc, Msg: "Hi part of pair should point to an even-numbered register");
481 OutContext.reportError(
482 L: Loc, Msg: "(note that in some cases it might be necessary to manually "
483 "bind the input/output registers instead of relying on "
484 "automatic allocation)");
485 return true;
486 }
487 }
488
489 HiReg = RegisterInfo->getSubReg(Reg: MOReg, Idx: SP::sub_even);
490 LoReg = RegisterInfo->getSubReg(Reg: MOReg, Idx: SP::sub_odd);
491
492 Register Reg;
493 switch (ExtraCode[0]) {
494 case 'L':
495 Reg = LoReg;
496 break;
497 case 'H':
498 Reg = HiReg;
499 break;
500 }
501
502 O << '%' << SparcInstPrinter::getRegisterName(Reg);
503 return false;
504 }
505 case 'r': {
506 const MachineOperand &MO = MI->getOperand(i: OpNo);
507 if (MO.isImm() && MO.getImm() == 0) {
508 O << "%g0";
509 return false;
510 }
511 break;
512 }
513 case 'f':
514 break;
515 }
516 }
517
518 printOperand(MI, opNum: OpNo, O);
519
520 return false;
521}
522
523bool SparcAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
524 unsigned OpNo,
525 const char *ExtraCode,
526 raw_ostream &O) {
527 if (ExtraCode && ExtraCode[0])
528 return true; // Unknown modifier
529
530 O << '[';
531 printMemOperand(MI, opNum: OpNo, O);
532 O << ']';
533
534 return false;
535}
536
537char SparcAsmPrinter::ID = 0;
538
539INITIALIZE_PASS(SparcAsmPrinter, "sparc-asm-printer", "Sparc Assembly Printer",
540 false, false)
541
542// Force static initialization.
543extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
544LLVMInitializeSparcAsmPrinter() {
545 RegisterAsmPrinter<SparcAsmPrinter> X(getTheSparcTarget());
546 RegisterAsmPrinter<SparcAsmPrinter> Y(getTheSparcV9Target());
547 RegisterAsmPrinter<SparcAsmPrinter> Z(getTheSparcelTarget());
548}
549
550PreservedAnalyses SparcAsmPrinterBeginPass::run(Module &M,
551 ModuleAnalysisManager &MAM) {
552 SparcAsmPrinter &AsmPrinter = static_cast<SparcAsmPrinter &>(
553 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
554 setupModuleAsmPrinter(M, MAM, AsmPrinter);
555 AsmPrinter.doInitialization(M);
556 return PreservedAnalyses::all();
557}
558
559PreservedAnalyses
560SparcAsmPrinterPass::run(MachineFunction &MF,
561 MachineFunctionAnalysisManager &MFAM) {
562 SparcAsmPrinter &AsmPrinter = static_cast<SparcAsmPrinter &>(
563 MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(IR&: MF)
564 .getCachedResult<AsmPrinterAnalysis>(IR&: *MF.getFunction().getParent())
565 ->getPrinter());
566 setupMachineFunctionAsmPrinter(MFAM, MF, AsmPrinter);
567 AsmPrinter.runOnMachineFunction(MF);
568 return PreservedAnalyses::all();
569}
570
571PreservedAnalyses SparcAsmPrinterEndPass::run(Module &M,
572 ModuleAnalysisManager &MAM) {
573 SparcAsmPrinter &AsmPrinter = static_cast<SparcAsmPrinter &>(
574 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
575 setupModuleAsmPrinter(M, MAM, AsmPrinter);
576 AsmPrinter.doFinalization(M);
577 return PreservedAnalyses::all();
578}
579