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"
35using namespace llvm;
36
37#define DEBUG_TYPE "ve-asmprinter"
38
39namespace {
40class VEAsmPrinter : public AsmPrinter {
41 VETargetStreamer &getTargetStreamer() {
42 return static_cast<VETargetStreamer &>(*OutStreamer->getTargetStreamer());
43 }
44
45public:
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 *ExtraCode, raw_ostream &O) override;
66 bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
67 const char *ExtraCode, raw_ostream &O) override;
68
69 static char ID;
70};
71} // end of anonymous namespace
72
73static 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
80static 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
86static 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
94static 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
106static 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
118static 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
130static 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
142static 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
154static 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
165static 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
170static 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
182void 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
222void 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
268void 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
323void 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
353void 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.
370bool VEAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
371 const char *ExtraCode, 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
391bool VEAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
392 const char *ExtraCode,
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
419char VEAsmPrinter::ID = 0;
420
421INITIALIZE_PASS(VEAsmPrinter, "ve-asm-printer", "VE Assembly Printer", false,
422 false)
423
424// Force static initialization.
425extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void LLVMInitializeVEAsmPrinter() {
426 RegisterAsmPrinter<VEAsmPrinter> X(getTheVETarget());
427}
428
429PreservedAnalyses 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
438PreservedAnalyses 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
449PreservedAnalyses 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