1//===-- SystemZAsmPrinter.cpp - SystemZ LLVM assembly printer -------------===//
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// Streams SystemZ assembly language and associated data, in the form of
10// MCInsts and MCExprs respectively.
11//
12//===----------------------------------------------------------------------===//
13
14#include "SystemZAsmPrinter.h"
15#include "MCTargetDesc/SystemZGNUInstPrinter.h"
16#include "MCTargetDesc/SystemZHLASMInstPrinter.h"
17#include "MCTargetDesc/SystemZMCAsmInfo.h"
18#include "MCTargetDesc/SystemZMCTargetDesc.h"
19#include "SystemZELFAsmPrinter.h"
20#include "SystemZMCInstLower.h"
21#include "SystemZSubtarget.h"
22#include "SystemZXPLINKAsmPrinter.h"
23#include "TargetInfo/SystemZTargetInfo.h"
24#include "llvm/CodeGen/AsmPrinterAnalysis.h"
25#include "llvm/CodeGen/MachineInstr.h"
26#include "llvm/MC/MCExpr.h"
27#include "llvm/MC/MCInstBuilder.h"
28#include "llvm/MC/MCStreamer.h"
29#include "llvm/MC/TargetRegistry.h"
30#include "llvm/Support/Compiler.h"
31
32using namespace llvm;
33
34// Return an RI instruction like MI with opcode Opcode, but with the
35// GR64 register operands turned into GR32s.
36static MCInst lowerRILow(const MachineInstr *MI, unsigned Opcode) {
37 if (MI->isCompare())
38 return MCInstBuilder(Opcode)
39 .addReg(Reg: SystemZMC::getRegAsGR32(Reg: MI->getOperand(i: 0).getReg()))
40 .addImm(Val: MI->getOperand(i: 1).getImm());
41 else
42 return MCInstBuilder(Opcode)
43 .addReg(Reg: SystemZMC::getRegAsGR32(Reg: MI->getOperand(i: 0).getReg()))
44 .addReg(Reg: SystemZMC::getRegAsGR32(Reg: MI->getOperand(i: 1).getReg()))
45 .addImm(Val: MI->getOperand(i: 2).getImm());
46}
47
48// Return an RI instruction like MI with opcode Opcode, but with the
49// GR64 register operands turned into GRH32s.
50static MCInst lowerRIHigh(const MachineInstr *MI, unsigned Opcode) {
51 if (MI->isCompare())
52 return MCInstBuilder(Opcode)
53 .addReg(Reg: SystemZMC::getRegAsGRH32(Reg: MI->getOperand(i: 0).getReg()))
54 .addImm(Val: MI->getOperand(i: 1).getImm());
55 else
56 return MCInstBuilder(Opcode)
57 .addReg(Reg: SystemZMC::getRegAsGRH32(Reg: MI->getOperand(i: 0).getReg()))
58 .addReg(Reg: SystemZMC::getRegAsGRH32(Reg: MI->getOperand(i: 1).getReg()))
59 .addImm(Val: MI->getOperand(i: 2).getImm());
60}
61
62// Return an RI instruction like MI with opcode Opcode, but with the
63// R2 register turned into a GR64.
64static MCInst lowerRIEfLow(const MachineInstr *MI, unsigned Opcode) {
65 return MCInstBuilder(Opcode)
66 .addReg(Reg: MI->getOperand(i: 0).getReg())
67 .addReg(Reg: MI->getOperand(i: 1).getReg())
68 .addReg(Reg: SystemZMC::getRegAsGR64(Reg: MI->getOperand(i: 2).getReg()))
69 .addImm(Val: MI->getOperand(i: 3).getImm())
70 .addImm(Val: MI->getOperand(i: 4).getImm())
71 .addImm(Val: MI->getOperand(i: 5).getImm());
72}
73
74// MI is an instruction that accepts an optional alignment hint,
75// and which was already lowered to LoweredMI. If the alignment
76// of the original memory operand is known, update LoweredMI to
77// an instruction with the corresponding hint set.
78static void lowerAlignmentHint(const MachineInstr *MI, MCInst &LoweredMI,
79 unsigned Opcode) {
80 if (MI->memoperands_empty())
81 return;
82
83 Align Alignment = Align(16);
84 for (const MachineMemOperand *MMO : MI->memoperands())
85 if (MMO->getAlign() < Alignment)
86 Alignment = MMO->getAlign();
87
88 unsigned AlignmentHint = 0;
89 if (Alignment >= Align(16))
90 AlignmentHint = 4;
91 else if (Alignment >= Align(8))
92 AlignmentHint = 3;
93 if (AlignmentHint == 0)
94 return;
95
96 LoweredMI.setOpcode(Opcode);
97 LoweredMI.addOperand(Op: MCOperand::createImm(Val: AlignmentHint));
98}
99
100// MI loads the high part of a vector from memory. Return an instruction
101// that uses replicating vector load Opcode to do the same thing.
102static MCInst lowerSubvectorLoad(const MachineInstr *MI, unsigned Opcode) {
103 return MCInstBuilder(Opcode)
104 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 0).getReg()))
105 .addReg(Reg: MI->getOperand(i: 1).getReg())
106 .addImm(Val: MI->getOperand(i: 2).getImm())
107 .addReg(Reg: MI->getOperand(i: 3).getReg());
108}
109
110// MI stores the high part of a vector to memory. Return an instruction
111// that uses elemental vector store Opcode to do the same thing.
112static MCInst lowerSubvectorStore(const MachineInstr *MI, unsigned Opcode) {
113 return MCInstBuilder(Opcode)
114 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 0).getReg()))
115 .addReg(Reg: MI->getOperand(i: 1).getReg())
116 .addImm(Val: MI->getOperand(i: 2).getImm())
117 .addReg(Reg: MI->getOperand(i: 3).getReg())
118 .addImm(Val: 0);
119}
120
121// MI extracts the first element of the source vector.
122static MCInst lowerVecEltExtraction(const MachineInstr *MI, unsigned Opcode) {
123 return MCInstBuilder(Opcode)
124 .addReg(Reg: SystemZMC::getRegAsGR64(Reg: MI->getOperand(i: 0).getReg()))
125 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 1).getReg()))
126 .addReg(Reg: 0)
127 .addImm(Val: 0);
128}
129
130// MI inserts value into the first element of the destination vector.
131static MCInst lowerVecEltInsertion(const MachineInstr *MI, unsigned Opcode) {
132 return MCInstBuilder(Opcode)
133 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 0).getReg()))
134 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 0).getReg()))
135 .addReg(Reg: MI->getOperand(i: 1).getReg())
136 .addReg(Reg: 0)
137 .addImm(Val: 0);
138}
139
140void SystemZAsmPrinter::emitInstruction(const MachineInstr *MI) {
141 SystemZ_MC::verifyInstructionPredicates(Opcode: MI->getOpcode(),
142 Features: getSubtargetInfo().getFeatureBits());
143
144 SystemZMCInstLower Lower(MF->getContext(), *this);
145 MCInst LoweredMI;
146 switch (MI->getOpcode()) {
147 case SystemZ::Return:
148 LoweredMI = MCInstBuilder(SystemZ::BR)
149 .addReg(Reg: SystemZ::R14D);
150 break;
151
152 case SystemZ::CondReturn:
153 LoweredMI = MCInstBuilder(SystemZ::BCR)
154 .addImm(Val: MI->getOperand(i: 0).getImm())
155 .addImm(Val: MI->getOperand(i: 1).getImm())
156 .addReg(Reg: SystemZ::R14D);
157 break;
158
159 case SystemZ::CRBReturn:
160 LoweredMI = MCInstBuilder(SystemZ::CRB)
161 .addReg(Reg: MI->getOperand(i: 0).getReg())
162 .addReg(Reg: MI->getOperand(i: 1).getReg())
163 .addImm(Val: MI->getOperand(i: 2).getImm())
164 .addReg(Reg: SystemZ::R14D)
165 .addImm(Val: 0);
166 break;
167
168 case SystemZ::CGRBReturn:
169 LoweredMI = MCInstBuilder(SystemZ::CGRB)
170 .addReg(Reg: MI->getOperand(i: 0).getReg())
171 .addReg(Reg: MI->getOperand(i: 1).getReg())
172 .addImm(Val: MI->getOperand(i: 2).getImm())
173 .addReg(Reg: SystemZ::R14D)
174 .addImm(Val: 0);
175 break;
176
177 case SystemZ::CIBReturn:
178 LoweredMI = MCInstBuilder(SystemZ::CIB)
179 .addReg(Reg: MI->getOperand(i: 0).getReg())
180 .addImm(Val: MI->getOperand(i: 1).getImm())
181 .addImm(Val: MI->getOperand(i: 2).getImm())
182 .addReg(Reg: SystemZ::R14D)
183 .addImm(Val: 0);
184 break;
185
186 case SystemZ::CGIBReturn:
187 LoweredMI = MCInstBuilder(SystemZ::CGIB)
188 .addReg(Reg: MI->getOperand(i: 0).getReg())
189 .addImm(Val: MI->getOperand(i: 1).getImm())
190 .addImm(Val: MI->getOperand(i: 2).getImm())
191 .addReg(Reg: SystemZ::R14D)
192 .addImm(Val: 0);
193 break;
194
195 case SystemZ::CLRBReturn:
196 LoweredMI = MCInstBuilder(SystemZ::CLRB)
197 .addReg(Reg: MI->getOperand(i: 0).getReg())
198 .addReg(Reg: MI->getOperand(i: 1).getReg())
199 .addImm(Val: MI->getOperand(i: 2).getImm())
200 .addReg(Reg: SystemZ::R14D)
201 .addImm(Val: 0);
202 break;
203
204 case SystemZ::CLGRBReturn:
205 LoweredMI = MCInstBuilder(SystemZ::CLGRB)
206 .addReg(Reg: MI->getOperand(i: 0).getReg())
207 .addReg(Reg: MI->getOperand(i: 1).getReg())
208 .addImm(Val: MI->getOperand(i: 2).getImm())
209 .addReg(Reg: SystemZ::R14D)
210 .addImm(Val: 0);
211 break;
212
213 case SystemZ::CLIBReturn:
214 LoweredMI = MCInstBuilder(SystemZ::CLIB)
215 .addReg(Reg: MI->getOperand(i: 0).getReg())
216 .addImm(Val: MI->getOperand(i: 1).getImm())
217 .addImm(Val: MI->getOperand(i: 2).getImm())
218 .addReg(Reg: SystemZ::R14D)
219 .addImm(Val: 0);
220 break;
221
222 case SystemZ::CLGIBReturn:
223 LoweredMI = MCInstBuilder(SystemZ::CLGIB)
224 .addReg(Reg: MI->getOperand(i: 0).getReg())
225 .addImm(Val: MI->getOperand(i: 1).getImm())
226 .addImm(Val: MI->getOperand(i: 2).getImm())
227 .addReg(Reg: SystemZ::R14D)
228 .addImm(Val: 0);
229 break;
230
231 case SystemZ::CallBR:
232 LoweredMI = MCInstBuilder(SystemZ::BR)
233 .addReg(Reg: MI->getOperand(i: 0).getReg());
234 break;
235
236 case SystemZ::CallBCR:
237 LoweredMI = MCInstBuilder(SystemZ::BCR)
238 .addImm(Val: MI->getOperand(i: 0).getImm())
239 .addImm(Val: MI->getOperand(i: 1).getImm())
240 .addReg(Reg: MI->getOperand(i: 2).getReg());
241 break;
242
243 case SystemZ::CRBCall:
244 LoweredMI = MCInstBuilder(SystemZ::CRB)
245 .addReg(Reg: MI->getOperand(i: 0).getReg())
246 .addReg(Reg: MI->getOperand(i: 1).getReg())
247 .addImm(Val: MI->getOperand(i: 2).getImm())
248 .addReg(Reg: MI->getOperand(i: 3).getReg())
249 .addImm(Val: 0);
250 break;
251
252 case SystemZ::CGRBCall:
253 LoweredMI = MCInstBuilder(SystemZ::CGRB)
254 .addReg(Reg: MI->getOperand(i: 0).getReg())
255 .addReg(Reg: MI->getOperand(i: 1).getReg())
256 .addImm(Val: MI->getOperand(i: 2).getImm())
257 .addReg(Reg: MI->getOperand(i: 3).getReg())
258 .addImm(Val: 0);
259 break;
260
261 case SystemZ::CIBCall:
262 LoweredMI = MCInstBuilder(SystemZ::CIB)
263 .addReg(Reg: MI->getOperand(i: 0).getReg())
264 .addImm(Val: MI->getOperand(i: 1).getImm())
265 .addImm(Val: MI->getOperand(i: 2).getImm())
266 .addReg(Reg: MI->getOperand(i: 3).getReg())
267 .addImm(Val: 0);
268 break;
269
270 case SystemZ::CGIBCall:
271 LoweredMI = MCInstBuilder(SystemZ::CGIB)
272 .addReg(Reg: MI->getOperand(i: 0).getReg())
273 .addImm(Val: MI->getOperand(i: 1).getImm())
274 .addImm(Val: MI->getOperand(i: 2).getImm())
275 .addReg(Reg: MI->getOperand(i: 3).getReg())
276 .addImm(Val: 0);
277 break;
278
279 case SystemZ::CLRBCall:
280 LoweredMI = MCInstBuilder(SystemZ::CLRB)
281 .addReg(Reg: MI->getOperand(i: 0).getReg())
282 .addReg(Reg: MI->getOperand(i: 1).getReg())
283 .addImm(Val: MI->getOperand(i: 2).getImm())
284 .addReg(Reg: MI->getOperand(i: 3).getReg())
285 .addImm(Val: 0);
286 break;
287
288 case SystemZ::CLGRBCall:
289 LoweredMI = MCInstBuilder(SystemZ::CLGRB)
290 .addReg(Reg: MI->getOperand(i: 0).getReg())
291 .addReg(Reg: MI->getOperand(i: 1).getReg())
292 .addImm(Val: MI->getOperand(i: 2).getImm())
293 .addReg(Reg: MI->getOperand(i: 3).getReg())
294 .addImm(Val: 0);
295 break;
296
297 case SystemZ::CLIBCall:
298 LoweredMI = MCInstBuilder(SystemZ::CLIB)
299 .addReg(Reg: MI->getOperand(i: 0).getReg())
300 .addImm(Val: MI->getOperand(i: 1).getImm())
301 .addImm(Val: MI->getOperand(i: 2).getImm())
302 .addReg(Reg: MI->getOperand(i: 3).getReg())
303 .addImm(Val: 0);
304 break;
305
306 case SystemZ::CLGIBCall:
307 LoweredMI = MCInstBuilder(SystemZ::CLGIB)
308 .addReg(Reg: MI->getOperand(i: 0).getReg())
309 .addImm(Val: MI->getOperand(i: 1).getImm())
310 .addImm(Val: MI->getOperand(i: 2).getImm())
311 .addReg(Reg: MI->getOperand(i: 3).getReg())
312 .addImm(Val: 0);
313 break;
314
315 case SystemZ::IILF64:
316 LoweredMI = MCInstBuilder(SystemZ::IILF)
317 .addReg(Reg: SystemZMC::getRegAsGR32(Reg: MI->getOperand(i: 0).getReg()))
318 .addImm(Val: MI->getOperand(i: 2).getImm());
319 break;
320
321 case SystemZ::IIHF64:
322 LoweredMI = MCInstBuilder(SystemZ::IIHF)
323 .addReg(Reg: SystemZMC::getRegAsGRH32(Reg: MI->getOperand(i: 0).getReg()))
324 .addImm(Val: MI->getOperand(i: 2).getImm());
325 break;
326
327 case SystemZ::RISBHH:
328 case SystemZ::RISBHL:
329 LoweredMI = lowerRIEfLow(MI, Opcode: SystemZ::RISBHG);
330 break;
331
332 case SystemZ::RISBLH:
333 case SystemZ::RISBLL:
334 LoweredMI = lowerRIEfLow(MI, Opcode: SystemZ::RISBLG);
335 break;
336
337 case SystemZ::VLVGP32:
338 LoweredMI = MCInstBuilder(SystemZ::VLVGP)
339 .addReg(Reg: MI->getOperand(i: 0).getReg())
340 .addReg(Reg: SystemZMC::getRegAsGR64(Reg: MI->getOperand(i: 1).getReg()))
341 .addReg(Reg: SystemZMC::getRegAsGR64(Reg: MI->getOperand(i: 2).getReg()));
342 break;
343
344 case SystemZ::VLR16:
345 case SystemZ::VLR32:
346 case SystemZ::VLR64:
347 LoweredMI = MCInstBuilder(SystemZ::VLR)
348 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 0).getReg()))
349 .addReg(Reg: SystemZMC::getRegAsVR128(Reg: MI->getOperand(i: 1).getReg()));
350 break;
351
352 case SystemZ::VL:
353 Lower.lower(MI, OutMI&: LoweredMI);
354 lowerAlignmentHint(MI, LoweredMI, Opcode: SystemZ::VLAlign);
355 break;
356
357 case SystemZ::VST:
358 Lower.lower(MI, OutMI&: LoweredMI);
359 lowerAlignmentHint(MI, LoweredMI, Opcode: SystemZ::VSTAlign);
360 break;
361
362 case SystemZ::VLM:
363 Lower.lower(MI, OutMI&: LoweredMI);
364 lowerAlignmentHint(MI, LoweredMI, Opcode: SystemZ::VLMAlign);
365 break;
366
367 case SystemZ::VSTM:
368 Lower.lower(MI, OutMI&: LoweredMI);
369 lowerAlignmentHint(MI, LoweredMI, Opcode: SystemZ::VSTMAlign);
370 break;
371
372 case SystemZ::VL16:
373 LoweredMI = lowerSubvectorLoad(MI, Opcode: SystemZ::VLREPH);
374 break;
375
376 case SystemZ::VL32:
377 LoweredMI = lowerSubvectorLoad(MI, Opcode: SystemZ::VLREPF);
378 break;
379
380 case SystemZ::VL64:
381 LoweredMI = lowerSubvectorLoad(MI, Opcode: SystemZ::VLREPG);
382 break;
383
384 case SystemZ::VST16:
385 LoweredMI = lowerSubvectorStore(MI, Opcode: SystemZ::VSTEH);
386 break;
387
388 case SystemZ::VST32:
389 LoweredMI = lowerSubvectorStore(MI, Opcode: SystemZ::VSTEF);
390 break;
391
392 case SystemZ::VST64:
393 LoweredMI = lowerSubvectorStore(MI, Opcode: SystemZ::VSTEG);
394 break;
395
396 case SystemZ::LFER:
397 LoweredMI = lowerVecEltExtraction(MI, Opcode: SystemZ::VLGVF);
398 break;
399
400 case SystemZ::LFER_16:
401 LoweredMI = lowerVecEltExtraction(MI, Opcode: SystemZ::VLGVH);
402 break;
403
404 case SystemZ::LEFR:
405 LoweredMI = lowerVecEltInsertion(MI, Opcode: SystemZ::VLVGF);
406 break;
407
408 case SystemZ::LEFR_16:
409 LoweredMI = lowerVecEltInsertion(MI, Opcode: SystemZ::VLVGH);
410 break;
411
412#define LOWER_LOW(NAME) \
413 case SystemZ::NAME##64: LoweredMI = lowerRILow(MI, SystemZ::NAME); break
414
415 LOWER_LOW(IILL);
416 LOWER_LOW(IILH);
417 LOWER_LOW(TMLL);
418 LOWER_LOW(TMLH);
419 LOWER_LOW(NILL);
420 LOWER_LOW(NILH);
421 LOWER_LOW(NILF);
422 LOWER_LOW(OILL);
423 LOWER_LOW(OILH);
424 LOWER_LOW(OILF);
425 LOWER_LOW(XILF);
426
427#undef LOWER_LOW
428
429#define LOWER_HIGH(NAME) \
430 case SystemZ::NAME##64: LoweredMI = lowerRIHigh(MI, SystemZ::NAME); break
431
432 LOWER_HIGH(IIHL);
433 LOWER_HIGH(IIHH);
434 LOWER_HIGH(TMHL);
435 LOWER_HIGH(TMHH);
436 LOWER_HIGH(NIHL);
437 LOWER_HIGH(NIHH);
438 LOWER_HIGH(NIHF);
439 LOWER_HIGH(OIHL);
440 LOWER_HIGH(OIHH);
441 LOWER_HIGH(OIHF);
442 LOWER_HIGH(XIHF);
443
444#undef LOWER_HIGH
445
446 case SystemZ::Serialize:
447 if (MF->getSubtarget<SystemZSubtarget>().hasFastSerialization())
448 LoweredMI = MCInstBuilder(SystemZ::BCRAsm)
449 .addImm(Val: 14).addReg(Reg: SystemZ::R0D);
450 else
451 LoweredMI = MCInstBuilder(SystemZ::BCRAsm)
452 .addImm(Val: 15).addReg(Reg: SystemZ::R0D);
453 break;
454
455 // We want to emit "j .+2" for traps, jumping to the relative immediate field
456 // of the jump instruction, which is an illegal instruction. We cannot emit a
457 // "." symbol, so create and emit a temp label before the instruction and use
458 // that instead.
459 case SystemZ::Trap: {
460 MCSymbol *DotSym = OutContext.createTempSymbol();
461 OutStreamer->emitLabel(Symbol: DotSym);
462
463 const MCSymbolRefExpr *Expr = MCSymbolRefExpr::create(Symbol: DotSym, Ctx&: OutContext);
464 const MCConstantExpr *ConstExpr = MCConstantExpr::create(Value: 2, Ctx&: OutContext);
465 LoweredMI = MCInstBuilder(SystemZ::J)
466 .addExpr(Val: MCBinaryExpr::createAdd(LHS: Expr, RHS: ConstExpr, Ctx&: OutContext));
467 }
468 break;
469
470 // Conditional traps will create a branch on condition instruction that jumps
471 // to the relative immediate field of the jump instruction. (eg. "jo .+2")
472 case SystemZ::CondTrap: {
473 MCSymbol *DotSym = OutContext.createTempSymbol();
474 OutStreamer->emitLabel(Symbol: DotSym);
475
476 const MCSymbolRefExpr *Expr = MCSymbolRefExpr::create(Symbol: DotSym, Ctx&: OutContext);
477 const MCConstantExpr *ConstExpr = MCConstantExpr::create(Value: 2, Ctx&: OutContext);
478 LoweredMI = MCInstBuilder(SystemZ::BRC)
479 .addImm(Val: MI->getOperand(i: 0).getImm())
480 .addImm(Val: MI->getOperand(i: 1).getImm())
481 .addExpr(Val: MCBinaryExpr::createAdd(LHS: Expr, RHS: ConstExpr, Ctx&: OutContext));
482 }
483 break;
484
485 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
486 llvm_unreachable("PATCHABLE_FUNCTION_EXIT should never be emitted");
487
488 case TargetOpcode::PATCHABLE_TAIL_CALL:
489 // TODO: Define a trampoline `__xray_FunctionTailExit` and differentiate a
490 // normal function exit from a tail exit.
491 llvm_unreachable("Tail call is handled in the normal case. See comments "
492 "around this assert.");
493
494 case SystemZ::EXRL_Pseudo: {
495 unsigned TargetInsOpc = MI->getOperand(i: 0).getImm();
496 Register LenMinus1Reg = MI->getOperand(i: 1).getReg();
497 Register DestReg = MI->getOperand(i: 2).getReg();
498 int64_t DestDisp = MI->getOperand(i: 3).getImm();
499 Register SrcReg = MI->getOperand(i: 4).getReg();
500 int64_t SrcDisp = MI->getOperand(i: 5).getImm();
501
502 SystemZTargetStreamer *TS = getTargetStreamer();
503 MCInst ET = MCInstBuilder(TargetInsOpc)
504 .addReg(Reg: DestReg)
505 .addImm(Val: DestDisp)
506 .addImm(Val: 1)
507 .addReg(Reg: SrcReg)
508 .addImm(Val: SrcDisp);
509 SystemZTargetStreamer::MCInstSTIPair ET_STI(ET, &MF->getSubtarget());
510 auto [It, Inserted] = TS->EXRLTargets2Sym.try_emplace(k: ET_STI);
511 if (Inserted)
512 It->second = OutContext.createTempSymbol();
513 MCSymbol *DotSym = It->second;
514 const MCSymbolRefExpr *Dot = MCSymbolRefExpr::create(Symbol: DotSym, Ctx&: OutContext);
515 EmitToStreamer(
516 S&: *OutStreamer,
517 Inst: MCInstBuilder(SystemZ::EXRL).addReg(Reg: LenMinus1Reg).addExpr(Val: Dot));
518 return;
519 }
520
521 case SystemZ::FENCE:
522 OutStreamer->emitRawComment(T: "FENCE");
523 return;
524
525 // EH_SjLj_Setup is a dummy terminator instruction of size 0.
526 // It is used to handle the clobber register for builtin setjmp.
527 case SystemZ::EH_SjLj_Setup:
528 return;
529
530 default:
531 Lower.lower(MI, OutMI&: LoweredMI);
532 break;
533 }
534 EmitToStreamer(S&: *OutStreamer, Inst: LoweredMI);
535}
536
537static void printFormattedRegName(const MCAsmInfo *MAI, unsigned RegNo,
538 raw_ostream &OS) {
539 const char *RegName;
540 if (MAI->getAssemblerDialect() == AD_HLASM) {
541 RegName = SystemZHLASMInstPrinter::getRegisterName(Reg: RegNo);
542 // Skip register prefix so that only register number is left
543 assert(isalpha(RegName[0]) && isdigit(RegName[1]));
544 OS << (RegName + 1);
545 } else {
546 RegName = SystemZGNUInstPrinter::getRegisterName(Reg: RegNo);
547 OS << '%' << RegName;
548 }
549}
550
551static void printReg(unsigned Reg, const MCAsmInfo *MAI, raw_ostream &OS) {
552 if (!Reg)
553 OS << '0';
554 else
555 printFormattedRegName(MAI, RegNo: Reg, OS);
556}
557
558static void printOperand(const MCOperand &MCOp, const MCAsmInfo *MAI,
559 raw_ostream &OS) {
560 if (MCOp.isReg())
561 printReg(Reg: MCOp.getReg(), MAI, OS);
562 else if (MCOp.isImm())
563 OS << MCOp.getImm();
564 else if (MCOp.isExpr())
565 MAI->printExpr(OS, *MCOp.getExpr());
566 else
567 llvm_unreachable("Invalid operand");
568}
569
570static void printAddress(const MCAsmInfo *MAI, unsigned Base,
571 const MCOperand &DispMO, unsigned Index,
572 raw_ostream &OS) {
573 printOperand(MCOp: DispMO, MAI, OS);
574 if (Base || Index) {
575 OS << '(';
576 if (Index) {
577 printFormattedRegName(MAI, RegNo: Index, OS);
578 if (Base)
579 OS << ',';
580 }
581 if (Base)
582 printFormattedRegName(MAI, RegNo: Base, OS);
583 OS << ')';
584 }
585}
586
587bool SystemZAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
588 const char *ExtraCode,
589 raw_ostream &OS) {
590 const MCRegisterInfo &MRI = TM.getMCRegisterInfo();
591 const MachineOperand &MO = MI->getOperand(i: OpNo);
592 MCOperand MCOp;
593 if (ExtraCode) {
594 if ((ExtraCode[0] == 'N' || ExtraCode[0] == 'M') && !ExtraCode[1] &&
595 MO.isReg() && SystemZ::GR128BitRegClass.contains(Reg: MO.getReg()))
596 MCOp =
597 MCOperand::createReg(Reg: MRI.getSubReg(Reg: MO.getReg(), Idx: SystemZ::subreg_l64));
598 else
599 return AsmPrinter::PrintAsmOperand(MI, OpNo, ExtraCode, OS);
600 } else {
601 SystemZMCInstLower Lower(MF->getContext(), *this);
602 MCOp = Lower.lowerOperand(MO);
603 }
604 printOperand(MCOp, MAI: &MAI, OS);
605 return false;
606}
607
608bool SystemZAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
609 unsigned OpNo,
610 const char *ExtraCode,
611 raw_ostream &OS) {
612 if (ExtraCode && ExtraCode[0] && !ExtraCode[1]) {
613 switch (ExtraCode[0]) {
614 case 'A':
615 // Unlike EmitMachineNode(), EmitSpecialNode(INLINEASM) does not call
616 // setMemRefs(), so MI->memoperands() is empty and the alignment
617 // information is not available.
618 return false;
619 case 'O':
620 OS << MI->getOperand(i: OpNo + 1).getImm();
621 return false;
622 case 'R':
623 ::printReg(Reg: MI->getOperand(i: OpNo).getReg(), MAI: &MAI, OS);
624 return false;
625 }
626 }
627 printAddress(MAI: &MAI, Base: MI->getOperand(i: OpNo).getReg(),
628 DispMO: MCOperand::createImm(Val: MI->getOperand(i: OpNo + 1).getImm()),
629 Index: MI->getOperand(i: OpNo + 2).getReg(), OS);
630 return false;
631}
632
633char SystemZAsmPrinter::ID = 0;
634
635INITIALIZE_PASS(SystemZAsmPrinter, "systemz-asm-printer",
636 "SystemZ Assembly Printer", false, false)
637
638static AsmPrinter *
639createSystemZAsmPrinter(TargetMachine &TM,
640 std::unique_ptr<MCStreamer> &&Streamer) {
641 if (TM.getTargetTriple().isOSzOS())
642 return new SystemZXPLINKAsmPrinter(TM, std::move(Streamer));
643 return new SystemZELFAsmPrinter(TM, std::move(Streamer));
644}
645
646// Force static initialization.
647extern "C" LLVM_ABI LLVM_EXTERNAL_VISIBILITY void
648LLVMInitializeSystemZAsmPrinter() {
649 TargetRegistry::RegisterAsmPrinter(T&: getTheSystemZTarget(),
650 Fn: createSystemZAsmPrinter);
651}
652
653PreservedAnalyses SystemZAsmPrinterBeginPass::run(Module &M,
654 ModuleAnalysisManager &MAM) {
655 SystemZAsmPrinter &AsmPrinter = static_cast<SystemZAsmPrinter &>(
656 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
657 setupModuleAsmPrinter(M, MAM, AsmPrinter);
658 AsmPrinter.doInitialization(M);
659 return PreservedAnalyses::all();
660}
661
662PreservedAnalyses
663SystemZAsmPrinterPass::run(MachineFunction &MF,
664 MachineFunctionAnalysisManager &MFAM) {
665 SystemZAsmPrinter &AsmPrinter = static_cast<SystemZAsmPrinter &>(
666 MFAM.getResult<ModuleAnalysisManagerMachineFunctionProxy>(IR&: MF)
667 .getCachedResult<AsmPrinterAnalysis>(IR&: *MF.getFunction().getParent())
668 ->getPrinter());
669 setupMachineFunctionAsmPrinter(MFAM, MF, AsmPrinter);
670 AsmPrinter.runOnMachineFunction(MF);
671 return PreservedAnalyses::all();
672}
673
674PreservedAnalyses SystemZAsmPrinterEndPass::run(Module &M,
675 ModuleAnalysisManager &MAM) {
676 SystemZAsmPrinter &AsmPrinter = static_cast<SystemZAsmPrinter &>(
677 MAM.getResult<AsmPrinterAnalysis>(IR&: M).getPrinter());
678 setupModuleAsmPrinter(M, MAM, AsmPrinter);
679 AsmPrinter.doFinalization(M);
680 return PreservedAnalyses::all();
681}
682