LLVM 24.0.0git
LoongArchInstrInfo.cpp
Go to the documentation of this file.
1//=- LoongArchInstrInfo.cpp - LoongArch Instruction Information -*- C++ -*-===//
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 the LoongArch implementation of the TargetInstrInfo class.
10//
11//===----------------------------------------------------------------------===//
12
13#include "LoongArchInstrInfo.h"
14#include "LoongArch.h"
21#include "llvm/MC/MCContext.h"
24
25using namespace llvm;
26
28 "loongarch-disable-reloc-sched",
29 cl::desc("Disable scheduling of instructions with target flags"),
30 cl::init(false), cl::Hidden);
31
32#define GET_INSTRINFO_CTOR_DTOR
33#include "LoongArchGenInstrInfo.inc"
34
36 : LoongArchGenInstrInfo(STI, RegInfo, LoongArch::ADJCALLSTACKDOWN,
37 LoongArch::ADJCALLSTACKUP),
38 RegInfo(STI.getHwMode()), STI(STI) {}
39
41 return MCInstBuilder(LoongArch::ANDI)
42 .addReg(LoongArch::R0)
43 .addReg(LoongArch::R0)
44 .addImm(0);
45}
46
49 const DebugLoc &DL, Register DstReg,
50 Register SrcReg, bool KillSrc,
51 bool RenamableDest,
52 bool RenamableSrc) const {
53 if (LoongArch::GPRRegClass.contains(DstReg, SrcReg)) {
54 BuildMI(MBB, MBBI, DL, get(LoongArch::OR), DstReg)
55 .addReg(SrcReg, getKillRegState(KillSrc))
56 .addReg(LoongArch::R0);
57 return;
58 }
59
60 // VR->VR copies.
61 if (LoongArch::LSX128RegClass.contains(DstReg, SrcReg)) {
62 BuildMI(MBB, MBBI, DL, get(LoongArch::VORI_B), DstReg)
63 .addReg(SrcReg, getKillRegState(KillSrc))
64 .addImm(0);
65 return;
66 }
67
68 // XR->XR copies.
69 if (LoongArch::LASX256RegClass.contains(DstReg, SrcReg)) {
70 BuildMI(MBB, MBBI, DL, get(LoongArch::XVORI_B), DstReg)
71 .addReg(SrcReg, getKillRegState(KillSrc))
72 .addImm(0);
73 return;
74 }
75
76 // GPR->CFR copy.
77 if (LoongArch::CFRRegClass.contains(DstReg) &&
78 LoongArch::GPRRegClass.contains(SrcReg)) {
79 BuildMI(MBB, MBBI, DL, get(LoongArch::MOVGR2CF), DstReg)
80 .addReg(SrcReg, getKillRegState(KillSrc));
81 return;
82 }
83 // CFR->GPR copy.
84 if (LoongArch::GPRRegClass.contains(DstReg) &&
85 LoongArch::CFRRegClass.contains(SrcReg)) {
86 BuildMI(MBB, MBBI, DL, get(LoongArch::MOVCF2GR), DstReg)
87 .addReg(SrcReg, getKillRegState(KillSrc));
88 return;
89 }
90 // CFR->CFR copy.
91 if (LoongArch::CFRRegClass.contains(DstReg, SrcReg)) {
92 BuildMI(MBB, MBBI, DL, get(LoongArch::PseudoCopyCFR), DstReg)
93 .addReg(SrcReg, getKillRegState(KillSrc));
94 return;
95 }
96
97 // FPR->FPR copies.
98 unsigned Opc;
99 if (LoongArch::FPR32RegClass.contains(DstReg, SrcReg)) {
100 Opc = LoongArch::FMOV_S;
101 } else if (LoongArch::FPR64RegClass.contains(DstReg, SrcReg)) {
102 Opc = LoongArch::FMOV_D;
103 } else if (LoongArch::GPRRegClass.contains(DstReg) &&
104 LoongArch::FPR32RegClass.contains(SrcReg)) {
105 // FPR32 -> GPR copies
106 Opc = LoongArch::MOVFR2GR_S;
107 } else if (LoongArch::GPRRegClass.contains(DstReg) &&
108 LoongArch::FPR64RegClass.contains(SrcReg)) {
109 // FPR64 -> GPR copies
110 Opc = LoongArch::MOVFR2GR_D;
111 } else {
112 // TODO: support other copies.
113 llvm_unreachable("Impossible reg-to-reg copy");
114 }
115
116 BuildMI(MBB, MBBI, DL, get(Opc), DstReg)
117 .addReg(SrcReg, getKillRegState(KillSrc));
118}
119
122 bool IsKill, int FI, const TargetRegisterClass *RC,
123
124 Register VReg, MachineInstr::MIFlag Flags) const {
125 MachineFunction *MF = MBB.getParent();
126 MachineFrameInfo &MFI = MF->getFrameInfo();
127
128 unsigned Opcode;
129 if (LoongArch::GPRRegClass.hasSubClassEq(RC))
130 Opcode = TRI.getRegSizeInBits(LoongArch::GPRRegClass) == 32
131 ? LoongArch::ST_W
132 : LoongArch::ST_D;
133 else if (LoongArch::FPR32RegClass.hasSubClassEq(RC))
134 Opcode = LoongArch::FST_S;
135 else if (LoongArch::FPR64RegClass.hasSubClassEq(RC))
136 Opcode = LoongArch::FST_D;
137 else if (LoongArch::LSX128RegClass.hasSubClassEq(RC))
138 Opcode = LoongArch::VST;
139 else if (LoongArch::LASX256RegClass.hasSubClassEq(RC))
140 Opcode = LoongArch::XVST;
141 else if (LoongArch::CFRRegClass.hasSubClassEq(RC))
142 Opcode = LoongArch::PseudoST_CFR;
143 else
144 llvm_unreachable("Can't store this register to stack slot");
145
148 MFI.getObjectSize(FI), MFI.getObjectAlign(FI));
149
150 BuildMI(MBB, I, DebugLoc(), get(Opcode))
151 .addReg(SrcReg, getKillRegState(IsKill))
152 .addFrameIndex(FI)
153 .addImm(0)
154 .addMemOperand(MMO);
155}
156
159 int FI, const TargetRegisterClass *RC, Register VReg, unsigned SubReg,
160 MachineInstr::MIFlag Flags) const {
161 MachineFunction *MF = MBB.getParent();
162 MachineFrameInfo &MFI = MF->getFrameInfo();
163 DebugLoc DL;
164 if (I != MBB.end())
165 DL = I->getDebugLoc();
166
167 unsigned Opcode;
168 if (LoongArch::GPRRegClass.hasSubClassEq(RC))
169 Opcode = RegInfo.getRegSizeInBits(LoongArch::GPRRegClass) == 32
170 ? LoongArch::LD_W
171 : LoongArch::LD_D;
172 else if (LoongArch::FPR32RegClass.hasSubClassEq(RC))
173 Opcode = LoongArch::FLD_S;
174 else if (LoongArch::FPR64RegClass.hasSubClassEq(RC))
175 Opcode = LoongArch::FLD_D;
176 else if (LoongArch::LSX128RegClass.hasSubClassEq(RC))
177 Opcode = LoongArch::VLD;
178 else if (LoongArch::LASX256RegClass.hasSubClassEq(RC))
179 Opcode = LoongArch::XVLD;
180 else if (LoongArch::CFRRegClass.hasSubClassEq(RC))
181 Opcode = LoongArch::PseudoLD_CFR;
182 else
183 llvm_unreachable("Can't load this register from stack slot");
184
187 MFI.getObjectSize(FI), MFI.getObjectAlign(FI));
188
189 BuildMI(MBB, I, DL, get(Opcode), DstReg)
190 .addFrameIndex(FI)
191 .addImm(0)
192 .addMemOperand(MMO);
193}
194
196 int &FrameIndex) const {
197 TypeSize Dummy = TypeSize::getZero();
198 return isLoadFromStackSlot(MI, FrameIndex, Dummy);
199}
200
202 int &FrameIndex,
203 TypeSize &MemBytes) const {
204 switch (MI.getOpcode()) {
205 default:
206 return Register();
207 case LoongArch::LD_W:
208 case LoongArch::FLD_S:
209 MemBytes = TypeSize::getFixed(4);
210 break;
211 case LoongArch::LD_D:
212 case LoongArch::FLD_D:
213 MemBytes = TypeSize::getFixed(8);
214 break;
215 case LoongArch::VLD:
216 MemBytes = TypeSize::getFixed(16);
217 break;
218 case LoongArch::XVLD:
219 MemBytes = TypeSize::getFixed(32);
220 break;
221 }
222
223 if ((MI.getOperand(1).isFI()) && // is a stack slot
224 (MI.getOperand(2).isImm()) && // the imm is zero
225 (MI.getOperand(2).getImm() == 0)) {
226 FrameIndex = MI.getOperand(1).getIndex();
227 return MI.getOperand(0).getReg();
228 }
229
230 return Register();
231}
232
234 int &FrameIndex) const {
235 TypeSize Dummy = TypeSize::getZero();
236 return isStoreToStackSlot(MI, FrameIndex, Dummy);
237}
238
240 int &FrameIndex,
241 TypeSize &MemBytes) const {
242 switch (MI.getOpcode()) {
243 default:
244 return Register();
245 case LoongArch::ST_W:
246 case LoongArch::FST_S:
247 MemBytes = TypeSize::getFixed(4);
248 break;
249 case LoongArch::ST_D:
250 case LoongArch::FST_D:
251 MemBytes = TypeSize::getFixed(8);
252 break;
253 case LoongArch::VST:
254 MemBytes = TypeSize::getFixed(16);
255 break;
256 case LoongArch::XVST:
257 MemBytes = TypeSize::getFixed(32);
258 break;
259 }
260
261 if ((MI.getOperand(1).isFI()) && // is a stack slot
262 (MI.getOperand(2).isImm()) && // the imm is zero
263 (MI.getOperand(2).getImm() == 0)) {
264 FrameIndex = MI.getOperand(1).getIndex();
265 return MI.getOperand(0).getReg();
266 }
267
268 return Register();
269}
270
273 const DebugLoc &DL, Register DstReg,
274 uint64_t Val, MachineInstr::MIFlag Flag) const {
275 Register SrcReg = LoongArch::R0;
276
277 if (!STI.is64Bit() && !isInt<32>(Val))
278 report_fatal_error("Should only materialize 32-bit constants for LA32");
279
280 auto Seq = LoongArchMatInt::generateInstSeq(Val);
281 assert(!Seq.empty());
282
283 for (auto &Inst : Seq) {
284 switch (Inst.Opc) {
285 case LoongArch::LU12I_W:
286 BuildMI(MBB, MBBI, DL, get(Inst.Opc), DstReg)
287 .addImm(Inst.Imm)
288 .setMIFlag(Flag);
289 break;
290 case LoongArch::ADDI_W:
291 case LoongArch::ORI:
292 case LoongArch::LU32I_D: // "rj" is needed due to InstrInfo pattern
293 case LoongArch::LU52I_D:
294 case LoongArch::SLLI_D:
295 BuildMI(MBB, MBBI, DL, get(Inst.Opc), DstReg)
296 .addReg(SrcReg, RegState::Kill)
297 .addImm(Inst.Imm)
298 .setMIFlag(Flag);
299 break;
300 case LoongArch::BSTRINS_D:
301 BuildMI(MBB, MBBI, DL, get(Inst.Opc), DstReg)
302 .addReg(SrcReg, RegState::Kill)
303 .addReg(SrcReg, RegState::Kill)
304 .addImm(Inst.Imm >> 32)
305 .addImm(Inst.Imm & 0xFF)
306 .setMIFlag(Flag);
307 break;
308 default:
309 assert(false && "Unknown insn emitted by LoongArchMatInt");
310 }
311
312 // Only the first instruction has $zero as its source.
313 SrcReg = DstReg;
314 }
315}
316
318 unsigned Opcode = MI.getOpcode();
319
320 if (Opcode == TargetOpcode::INLINEASM ||
321 Opcode == TargetOpcode::INLINEASM_BR) {
322 const MachineFunction *MF = MI.getParent()->getParent();
323 const MCAsmInfo &MAI = MF->getTarget().getMCAsmInfo();
324 return getInlineAsmLength(MI.getOperand(0).getSymbolName(), MAI);
325 }
326
327 unsigned NumBytes = 0;
328 const MCInstrDesc &Desc = MI.getDesc();
329
330 // Size should be preferably set in
331 // llvm/lib/Target/LoongArch/LoongArch*InstrInfo.td (default case).
332 // Specific cases handle instructions of variable sizes.
333 switch (Desc.getOpcode()) {
334 default:
335 return Desc.getSize();
336 case TargetOpcode::STATEPOINT:
337 NumBytes = StatepointOpers(&MI).getNumPatchBytes();
338 assert(NumBytes % 4 == 0 && "Invalid number of NOP bytes requested!");
339 // No patch bytes means a normal call inst (i.e. `bl`) is emitted.
340 if (NumBytes == 0)
341 NumBytes = 4;
342 break;
343 case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
344 const MachineFunction *MF = MI.getParent()->getParent();
345 const Function &F = MF->getFunction();
346 if (F.hasFnAttribute("patchable-function-entry")) {
347 unsigned Num =
348 F.getFnAttributeAsParsedInteger("patchable-function-entry");
349 return Num * 4;
350 }
351 [[fallthrough]];
352 }
353 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
354 case TargetOpcode::PATCHABLE_TAIL_CALL:
355 // Size of xray sled (branch + 11 nops).
356 return 12 * 4;
357 case TargetOpcode::BUNDLE:
358 return getInstBundleSize(MI);
359 }
360 return NumBytes;
361}
362
364 const unsigned Opcode = MI.getOpcode();
365 switch (Opcode) {
366 default:
367 break;
368 case LoongArch::ADDI_D:
369 case LoongArch::ORI:
370 case LoongArch::XORI:
371 return (MI.getOperand(1).isReg() &&
372 MI.getOperand(1).getReg() == LoongArch::R0) ||
373 (MI.getOperand(2).isImm() && MI.getOperand(2).getImm() == 0);
374 }
375 return MI.isAsCheapAsAMove();
376}
377
378static bool isJumpTableLoad(const MachineInstr &MI) {
379 return any_of(MI.memoperands(), [](const MachineMemOperand *MMO) {
380 const PseudoSourceValue *PSV = MMO->getPseudoValue();
381 return PSV && PSV->isJumpTable();
382 });
383}
384
385// Return the index of the jump table whose address
386// (or an entry loaded from it) is held in Reg, or -1.
388 Register Reg) {
389 if (!Reg.isVirtual())
390 return -1;
391 const MachineInstr *MI = MRI.getUniqueVRegDef(Reg);
392 if (!MI)
393 return -1;
394
395 int JTI;
396 switch (MI->getOpcode()) {
397 case LoongArch::ADDI_D:
398 case LoongArch::ADDI_W:
399 case LoongArch::PseudoLA_PCREL:
400 for (const MachineOperand &MO : MI->operands())
401 if (MO.isJTI())
402 return MO.getIndex();
403 return -1;
404 case LoongArch::LDX_D:
405 case LoongArch::LDX_W:
406 // Normally, NonFIBaseAddr is corresponding to register $rj.
407 JTI = getJumpTableIndexFromReg(MRI, MI->getOperand(1).getReg());
408 if (JTI >= 0)
409 return JTI;
410 JTI = getJumpTableIndexFromReg(MRI, MI->getOperand(2).getReg());
411 if (JTI >= 0)
412 return JTI;
413 break;
414 default:
415 return -1;
416 }
417
418 return -1;
419}
420
421// LA32 do not support register offset load instrunctions (LDX),
422// so add another layer to get jump table address.
424 Register Reg) {
425 if (!Reg.isVirtual())
426 return -1;
427 const MachineInstr *MI = MRI.getUniqueVRegDef(Reg);
428 if (!MI)
429 return -1;
430
431 int JTI;
432 switch (MI->getOpcode()) {
433 case LoongArch::ADD_W:
434 JTI = getJumpTableIndexFromReg(MRI, MI->getOperand(1).getReg());
435 if (JTI >= 0)
436 return JTI;
437 JTI = getJumpTableIndexFromReg(MRI, MI->getOperand(2).getReg());
438 if (JTI >= 0)
439 return JTI;
440 break;
441 case LoongArch::ALSL_W:
442 // For la32s, address could only stores in register $rk.
443 return getJumpTableIndexFromReg(MRI, MI->getOperand(2).getReg());
444 }
445
446 return -1;
447}
448
449// Recursively search for %jump-table.N starting from PseudoBRIND,
450// and return the index of &jump-table.N
451//
452// One common jump table:
453//
454// %base = PseudoLA_PCREL %jump-table.N
455// %off = LDX_W %base, %index
456// %tgt = ADD_D %base, %off
457// %PseudoBRIND %tgt, 0
458//
460 if (MI.getOpcode() != LoongArch::PseudoBRIND)
461 return -1;
462
463 Register Reg = MI.getOperand(0).getReg();
464 if (!Reg.isVirtual())
465 return -1;
466
467 const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo();
468 MachineInstr *Def = MRI.getUniqueVRegDef(Reg);
469 if (!Def)
470 return -1;
471
472 int JTI;
473 switch (Def->getOpcode()) {
474 case LoongArch::LD_W:
475 if (!isJumpTableLoad(*Def))
476 return -1;
477
478 JTI = getJumpTableIndexFromLoadAddr(MRI, Def->getOperand(1).getReg());
479 if (JTI >= 0)
480 return JTI;
481 break;
482 case LoongArch::ADD_D:
483 case LoongArch::ADD_W:
484 JTI = getJumpTableIndexFromReg(MRI, Def->getOperand(1).getReg());
485 if (JTI >= 0)
486 return JTI;
487 return getJumpTableIndexFromReg(MRI, Def->getOperand(2).getReg());
488 }
489
490 return getJumpTableIndexFromReg(MRI, Reg);
491}
492
494 bool Invert) const {
495 unsigned Opc = Inst.getOpcode();
496 if (Invert) {
497 auto InverseOpcode = getInverseOpcode(Opc);
498 if (!InverseOpcode)
499 return false;
500 Opc = *InverseOpcode;
501 }
502
503 switch (Opc) {
504 default:
505 return false;
506 case LoongArch::FADD_S:
507 case LoongArch::FADD_D:
508 case LoongArch::FMUL_S:
509 case LoongArch::FMUL_D:
510 case LoongArch::VFADD_S:
511 case LoongArch::VFADD_D:
512 case LoongArch::VFMUL_S:
513 case LoongArch::VFMUL_D:
514 case LoongArch::XVFADD_S:
515 case LoongArch::XVFADD_D:
516 case LoongArch::XVFMUL_S:
517 case LoongArch::XVFMUL_D:
520 // IEEE 754-2008 minNum/maxNum: an sNaN operand yields qNaN, which breaks
521 // associativity (min(min(3,sNaN),1) = 1 but min(3,min(sNaN,1)) = 3).
522 // Signed zeros are ordered (-0 < +0) and the result is exact, so no
523 // reassoc/nsz requirement.
524 case LoongArch::FMIN_S:
525 case LoongArch::FMIN_D:
526 case LoongArch::FMAX_S:
527 case LoongArch::FMAX_D:
528 case LoongArch::VFMIN_S:
529 case LoongArch::VFMIN_D:
530 case LoongArch::VFMAX_S:
531 case LoongArch::VFMAX_D:
532 case LoongArch::XVFMIN_S:
533 case LoongArch::XVFMIN_D:
534 case LoongArch::XVFMAX_S:
535 case LoongArch::XVFMAX_D:
537 case LoongArch::ADD_D:
538 case LoongArch::ADD_W:
539 case LoongArch::AND:
540 case LoongArch::OR:
541 case LoongArch::XOR:
542 case LoongArch::MUL_D:
543 case LoongArch::MUL_W:
544 case LoongArch::VADD_B:
545 case LoongArch::VADD_H:
546 case LoongArch::VADD_W:
547 case LoongArch::VADD_D:
548 case LoongArch::VMUL_B:
549 case LoongArch::VMUL_H:
550 case LoongArch::VMUL_W:
551 case LoongArch::VMUL_D:
552 case LoongArch::VAND_V:
553 case LoongArch::VOR_V:
554 case LoongArch::VXOR_V:
555 case LoongArch::VMIN_B:
556 case LoongArch::VMIN_H:
557 case LoongArch::VMIN_W:
558 case LoongArch::VMIN_D:
559 case LoongArch::VMIN_BU:
560 case LoongArch::VMIN_HU:
561 case LoongArch::VMIN_WU:
562 case LoongArch::VMIN_DU:
563 case LoongArch::VMAX_B:
564 case LoongArch::VMAX_H:
565 case LoongArch::VMAX_W:
566 case LoongArch::VMAX_D:
567 case LoongArch::VMAX_BU:
568 case LoongArch::VMAX_HU:
569 case LoongArch::VMAX_WU:
570 case LoongArch::VMAX_DU:
571 case LoongArch::XVADD_B:
572 case LoongArch::XVADD_H:
573 case LoongArch::XVADD_W:
574 case LoongArch::XVADD_D:
575 case LoongArch::XVMUL_B:
576 case LoongArch::XVMUL_H:
577 case LoongArch::XVMUL_W:
578 case LoongArch::XVMUL_D:
579 case LoongArch::XVAND_V:
580 case LoongArch::XVOR_V:
581 case LoongArch::XVXOR_V:
582 case LoongArch::XVMIN_B:
583 case LoongArch::XVMIN_H:
584 case LoongArch::XVMIN_W:
585 case LoongArch::XVMIN_D:
586 case LoongArch::XVMIN_BU:
587 case LoongArch::XVMIN_HU:
588 case LoongArch::XVMIN_WU:
589 case LoongArch::XVMIN_DU:
590 case LoongArch::XVMAX_B:
591 case LoongArch::XVMAX_H:
592 case LoongArch::XVMAX_W:
593 case LoongArch::XVMAX_D:
594 case LoongArch::XVMAX_BU:
595 case LoongArch::XVMAX_HU:
596 case LoongArch::XVMAX_WU:
597 case LoongArch::XVMAX_DU:
598 return true;
599 }
600
601 return false;
602}
603
604std::optional<unsigned>
606 switch (Opcode) {
607 default:
608 return std::nullopt;
609 case LoongArch::ADD_W:
610 return LoongArch::SUB_W;
611 case LoongArch::ADD_D:
612 return LoongArch::SUB_D;
613 case LoongArch::SUB_W:
614 return LoongArch::ADD_W;
615 case LoongArch::SUB_D:
616 return LoongArch::ADD_D;
617 case LoongArch::FADD_S:
618 return LoongArch::FSUB_S;
619 case LoongArch::FADD_D:
620 return LoongArch::FSUB_D;
621 case LoongArch::FSUB_S:
622 return LoongArch::FADD_S;
623 case LoongArch::FSUB_D:
624 return LoongArch::FADD_D;
625 case LoongArch::VADD_B:
626 return LoongArch::VSUB_B;
627 case LoongArch::VADD_H:
628 return LoongArch::VSUB_H;
629 case LoongArch::VADD_W:
630 return LoongArch::VSUB_W;
631 case LoongArch::VADD_D:
632 return LoongArch::VSUB_D;
633 case LoongArch::VSUB_B:
634 return LoongArch::VADD_B;
635 case LoongArch::VSUB_H:
636 return LoongArch::VADD_H;
637 case LoongArch::VSUB_W:
638 return LoongArch::VADD_W;
639 case LoongArch::VSUB_D:
640 return LoongArch::VADD_D;
641 case LoongArch::VFADD_S:
642 return LoongArch::VFSUB_S;
643 case LoongArch::VFADD_D:
644 return LoongArch::VFSUB_D;
645 case LoongArch::VFSUB_S:
646 return LoongArch::VFADD_S;
647 case LoongArch::VFSUB_D:
648 return LoongArch::VFADD_D;
649 case LoongArch::XVADD_B:
650 return LoongArch::XVSUB_B;
651 case LoongArch::XVADD_H:
652 return LoongArch::XVSUB_H;
653 case LoongArch::XVADD_W:
654 return LoongArch::XVSUB_W;
655 case LoongArch::XVADD_D:
656 return LoongArch::XVSUB_D;
657 case LoongArch::XVSUB_B:
658 return LoongArch::XVADD_B;
659 case LoongArch::XVSUB_H:
660 return LoongArch::XVADD_H;
661 case LoongArch::XVSUB_W:
662 return LoongArch::XVADD_W;
663 case LoongArch::XVSUB_D:
664 return LoongArch::XVADD_D;
665 case LoongArch::XVFADD_S:
666 return LoongArch::XVFSUB_S;
667 case LoongArch::XVFADD_D:
668 return LoongArch::XVFSUB_D;
669 case LoongArch::XVFSUB_S:
670 return LoongArch::XVFADD_S;
671 case LoongArch::XVFSUB_D:
672 return LoongArch::XVFADD_D;
673 }
674}
675
678 assert(MI.getDesc().isBranch() && "Unexpected opcode!");
679 // The branch target is always the last operand.
680 return MI.getOperand(MI.getNumExplicitOperands() - 1).getMBB();
681}
682
685 // Block ends with fall-through condbranch.
686 assert(LastInst.getDesc().isConditionalBranch() &&
687 "Unknown conditional branch");
688 int NumOp = LastInst.getNumExplicitOperands();
689 Target = LastInst.getOperand(NumOp - 1).getMBB();
690
691 Cond.push_back(MachineOperand::CreateImm(LastInst.getOpcode()));
692 for (int i = 0; i < NumOp - 1; i++)
693 Cond.push_back(LastInst.getOperand(i));
694}
695
698 MachineBasicBlock *&FBB,
700 bool AllowModify) const {
701 TBB = FBB = nullptr;
702 Cond.clear();
703
704 // If the block has no terminators, it just falls into the block after it.
705 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
706 if (I == MBB.end() || !isUnpredicatedTerminator(*I))
707 return false;
708
709 // Count the number of terminators and find the first unconditional or
710 // indirect branch.
711 MachineBasicBlock::iterator FirstUncondOrIndirectBr = MBB.end();
712 int NumTerminators = 0;
713 for (auto J = I.getReverse(); J != MBB.rend() && isUnpredicatedTerminator(*J);
714 J++) {
715 NumTerminators++;
716 if (J->getDesc().isUnconditionalBranch() ||
717 J->getDesc().isIndirectBranch()) {
718 FirstUncondOrIndirectBr = J.getReverse();
719 }
720 }
721
722 // If AllowModify is true, we can erase any terminators after
723 // FirstUncondOrIndirectBR.
724 if (AllowModify && FirstUncondOrIndirectBr != MBB.end()) {
725 while (std::next(FirstUncondOrIndirectBr) != MBB.end()) {
726 std::next(FirstUncondOrIndirectBr)->eraseFromParent();
727 NumTerminators--;
728 }
729 I = FirstUncondOrIndirectBr;
730 }
731
732 // Handle a single unconditional branch.
733 if (NumTerminators == 1 && I->getDesc().isUnconditionalBranch()) {
735 return false;
736 }
737
738 // Handle a single conditional branch.
739 if (NumTerminators == 1 && I->getDesc().isConditionalBranch()) {
741 return false;
742 }
743
744 // Handle a conditional branch followed by an unconditional branch.
745 if (NumTerminators == 2 && std::prev(I)->getDesc().isConditionalBranch() &&
746 I->getDesc().isUnconditionalBranch()) {
747 parseCondBranch(*std::prev(I), TBB, Cond);
748 FBB = getBranchDestBlock(*I);
749 return false;
750 }
751
752 // Otherwise, we can't handle this.
753 return true;
754}
755
757 int64_t BrOffset) const {
758 switch (BranchOp) {
759 default:
760 llvm_unreachable("Unknown branch instruction!");
761 case LoongArch::BEQ:
762 case LoongArch::BNE:
763 case LoongArch::BLT:
764 case LoongArch::BGE:
765 case LoongArch::BLTU:
766 case LoongArch::BGEU:
767 return isInt<18>(BrOffset);
768 case LoongArch::BEQZ:
769 case LoongArch::BNEZ:
770 case LoongArch::BCEQZ:
771 case LoongArch::BCNEZ:
772 return isInt<23>(BrOffset);
773 case LoongArch::B:
774 case LoongArch::PseudoBR:
775 return isInt<28>(BrOffset);
776 }
777}
778
780 const MachineBasicBlock *MBB,
781 const MachineFunction &MF) const {
782 if (DisableRelocSched) {
783 for (const MachineOperand &MO : MI.operands())
784 if (MO.getTargetFlags())
785 return false;
786 }
787
788 auto MII = MI.getIterator();
789 auto MIE = MBB->end();
790
791 // According to psABI v2.30:
792 //
793 // https://github.com/loongson/la-abi-specs/releases/tag/v2.30
794 //
795 // The following instruction patterns are prohibited from being reordered:
796 //
797 // * pcalau12i $a0, %pc_hi20(s)
798 // addi.d $a1, $zero, %pc_lo12(s)
799 // lu32i.d $a1, %pc64_lo20(s)
800 // lu52i.d $a1, $a1, %pc64_hi12(s)
801 //
802 // * pcalau12i $a0, %got_pc_hi20(s) | %ld_pc_hi20(s) | %gd_pc_hi20(s)
803 // addi.d $a1, $zero, %got_pc_lo12(s)
804 // lu32i.d $a1, %got64_pc_lo20(s)
805 // lu52i.d $a1, $a1, %got64_pc_hi12(s)
806 //
807 // * pcalau12i $a0, %ie_pc_hi20(s)
808 // addi.d $a1, $zero, %ie_pc_lo12(s)
809 // lu32i.d $a1, %ie64_pc_lo20(s)
810 // lu52i.d $a1, $a1, %ie64_pc_hi12(s)
811 //
812 // * pcalau12i $a0, %desc_pc_hi20(s)
813 // addi.d $a1, $zero, %desc_pc_lo12(s)
814 // lu32i.d $a1, %desc64_pc_lo20(s)
815 // lu52i.d $a1, $a1, %desc64_pc_hi12(s)
816 //
817 // For simplicity, only pcalau12i and lu52i.d are marked as scheduling
818 // boundaries, and the instructions between them are guaranteed to be
819 // ordered according to data dependencies.
820 switch (MI.getOpcode()) {
821 case LoongArch::PCALAU12I: {
822 auto AddI = std::next(MII);
823 if (AddI == MIE || AddI->getOpcode() != LoongArch::ADDI_D)
824 break;
825 auto Lu32I = std::next(AddI);
826 if (Lu32I == MIE || Lu32I->getOpcode() != LoongArch::LU32I_D)
827 break;
828 auto MO0 = MI.getOperand(1).getTargetFlags();
829 auto MO1 = AddI->getOperand(2).getTargetFlags();
830 auto MO2 = Lu32I->getOperand(2).getTargetFlags();
833 return false;
835 MO0 == LoongArchII::MO_GD_PC_HI) &&
837 return false;
840 return false;
841 if (MO0 == LoongArchII::MO_DESC_PC_HI &&
844 return false;
845 break;
846 }
847 case LoongArch::LU52I_D: {
848 auto MO = MI.getOperand(2).getTargetFlags();
851 return false;
852 break;
853 }
854 default:
855 break;
856 }
857
858 const auto &STI = MF.getSubtarget<LoongArchSubtarget>();
859 if (STI.hasFeature(LoongArch::FeatureRelax)) {
860 // When linker relaxation enabled, the following instruction patterns are
861 // prohibited from being reordered:
862 //
863 // * pcalau12i $a0, %pc_hi20(s)
864 // addi.w/d $a0, $a0, %pc_lo12(s)
865 //
866 // * pcalau12i $a0, %got_pc_hi20(s)
867 // ld.w/d $a0, $a0, %got_pc_lo12(s)
868 //
869 // * pcalau12i $a0, %ld_pc_hi20(s) | %gd_pc_hi20(s)
870 // addi.w/d $a0, $a0, %got_pc_lo12(s)
871 //
872 // * pcalau12i $a0, %desc_pc_hi20(s)
873 // addi.w/d $a0, $a0, %desc_pc_lo12(s)
874 // ld.w/d $ra, $a0, %desc_ld(s)
875 // jirl $ra, $ra, %desc_call(s)
876 unsigned AddiOp = STI.is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W;
877 unsigned LdOp = STI.is64Bit() ? LoongArch::LD_D : LoongArch::LD_W;
878 switch (MI.getOpcode()) {
879 case LoongArch::PCALAU12I: {
880 auto MO0 = LoongArchII::getDirectFlags(MI.getOperand(1));
881 auto SecondOp = std::next(MII);
882 if (MO0 == LoongArchII::MO_DESC_PC_HI) {
883 if (SecondOp == MIE || SecondOp->getOpcode() != AddiOp)
884 break;
885 auto Ld = std::next(SecondOp);
886 if (Ld == MIE || Ld->getOpcode() != LdOp)
887 break;
888 auto MO1 = LoongArchII::getDirectFlags(SecondOp->getOperand(2));
889 auto MO2 = LoongArchII::getDirectFlags(Ld->getOperand(2));
891 return false;
892 break;
893 }
894 if (SecondOp == MIE ||
895 (SecondOp->getOpcode() != AddiOp && SecondOp->getOpcode() != LdOp))
896 break;
897 auto MO1 = LoongArchII::getDirectFlags(SecondOp->getOperand(2));
898 if (MO0 == LoongArchII::MO_PCREL_HI && SecondOp->getOpcode() == AddiOp &&
900 return false;
901 if (MO0 == LoongArchII::MO_GOT_PC_HI && SecondOp->getOpcode() == LdOp &&
903 return false;
904 if ((MO0 == LoongArchII::MO_LD_PC_HI ||
905 MO0 == LoongArchII::MO_GD_PC_HI) &&
906 SecondOp->getOpcode() == AddiOp && MO1 == LoongArchII::MO_GOT_PC_LO)
907 return false;
908 break;
909 }
910 case LoongArch::ADDI_W:
911 case LoongArch::ADDI_D: {
912 auto MO = LoongArchII::getDirectFlags(MI.getOperand(2));
914 return false;
915 break;
916 }
917 case LoongArch::LD_W:
918 case LoongArch::LD_D: {
919 auto MO = LoongArchII::getDirectFlags(MI.getOperand(2));
921 return false;
922 break;
923 }
924 case LoongArch::PseudoDESC_CALL: {
925 auto MO = LoongArchII::getDirectFlags(MI.getOperand(2));
927 return false;
928 break;
929 }
930 default:
931 break;
932 }
933 }
934
935 return true;
936}
937
939 const MachineBasicBlock *MBB,
940 const MachineFunction &MF) const {
942 return true;
943
944 if (!isSafeToMove(MI, MBB, MF))
945 return true;
946
947 return false;
948}
949
951 int *BytesRemoved) const {
952 if (BytesRemoved)
953 *BytesRemoved = 0;
954 MachineBasicBlock::iterator I = MBB.getLastNonDebugInstr();
955 if (I == MBB.end())
956 return 0;
957
958 if (!I->getDesc().isBranch())
959 return 0;
960
961 // Remove the branch.
962 if (BytesRemoved)
963 *BytesRemoved += getInstSizeInBytes(*I);
964 I->eraseFromParent();
965
966 I = MBB.end();
967
968 if (I == MBB.begin())
969 return 1;
970 --I;
971 if (!I->getDesc().isConditionalBranch())
972 return 1;
973
974 // Remove the branch.
975 if (BytesRemoved)
976 *BytesRemoved += getInstSizeInBytes(*I);
977 I->eraseFromParent();
978 return 2;
979}
980
981// Inserts a branch into the end of the specific MachineBasicBlock, returning
982// the number of instructions inserted.
985 ArrayRef<MachineOperand> Cond, const DebugLoc &DL, int *BytesAdded) const {
986 if (BytesAdded)
987 *BytesAdded = 0;
988
989 // Shouldn't be a fall through.
990 assert(TBB && "insertBranch must not be told to insert a fallthrough");
991 assert(Cond.size() <= 3 && Cond.size() != 1 &&
992 "LoongArch branch conditions have at most two components!");
993
994 // Unconditional branch.
995 if (Cond.empty()) {
996 MachineInstr &MI = *BuildMI(&MBB, DL, get(LoongArch::PseudoBR)).addMBB(TBB);
997 if (BytesAdded)
998 *BytesAdded += getInstSizeInBytes(MI);
999 return 1;
1000 }
1001
1002 // Either a one or two-way conditional branch.
1004 for (unsigned i = 1; i < Cond.size(); ++i)
1005 MIB.add(Cond[i]);
1006 MIB.addMBB(TBB);
1007 if (BytesAdded)
1008 *BytesAdded += getInstSizeInBytes(*MIB);
1009
1010 // One-way conditional branch.
1011 if (!FBB)
1012 return 1;
1013
1014 // Two-way conditional branch.
1015 MachineInstr &MI = *BuildMI(&MBB, DL, get(LoongArch::PseudoBR)).addMBB(FBB);
1016 if (BytesAdded)
1017 *BytesAdded += getInstSizeInBytes(MI);
1018 return 2;
1019}
1020
1022 MachineBasicBlock &DestBB,
1023 MachineBasicBlock &RestoreBB,
1024 const DebugLoc &DL,
1025 int64_t BrOffset,
1026 RegScavenger *RS) const {
1027 assert(RS && "RegScavenger required for long branching");
1028 assert(MBB.empty() &&
1029 "new block should be inserted for expanding unconditional branch");
1030 assert(MBB.pred_size() == 1);
1031
1032 MachineFunction *MF = MBB.getParent();
1037 bool Has32S = STI.hasFeature(LoongArch::Feature32S);
1038
1039 if (!isInt<32>(BrOffset))
1041 "Branch offsets outside of the signed 32-bit range not supported");
1042
1043 Register ScratchReg = MRI.createVirtualRegister(&LoongArch::GPRRegClass);
1044 MachineInstr *PCAI = nullptr;
1045 MachineInstr *ADDI = nullptr;
1046 auto II = MBB.end();
1047 unsigned ADDIOp = STI.is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W;
1048
1049 if (Has32S) {
1050 PCAI = BuildMI(MBB, II, DL, get(LoongArch::PCALAU12I), ScratchReg)
1052 ADDI = BuildMI(MBB, II, DL, get(ADDIOp), ScratchReg)
1053 .addReg(ScratchReg)
1055 } else {
1056 MCSymbol *PCAddSymbol = MF->getContext().createNamedTempSymbol("pcadd_hi");
1057 PCAI = BuildMI(MBB, II, DL, get(LoongArch::PCADDU12I), ScratchReg)
1059 PCAI->setPreInstrSymbol(*MF, PCAddSymbol);
1060 ADDI = BuildMI(MBB, II, DL, get(ADDIOp), ScratchReg)
1061 .addReg(ScratchReg)
1062 .addSym(PCAddSymbol, LoongArchII::MO_PCADD_LO);
1063 }
1064 BuildMI(MBB, II, DL, get(LoongArch::PseudoBRIND))
1065 .addReg(ScratchReg, RegState::Kill)
1066 .addImm(0);
1067
1068 RS->enterBasicBlockEnd(MBB);
1069 Register Scav = RS->scavengeRegisterBackwards(
1070 LoongArch::GPRRegClass, PCAI->getIterator(), /*RestoreAfter=*/false,
1071 /*SPAdj=*/0, /*AllowSpill=*/false);
1072 if (Scav != LoongArch::NoRegister)
1073 RS->setRegUsed(Scav);
1074 else {
1075 // When there is no scavenged register, it needs to specify a register.
1076 // Specify t8 register because it won't be used too often.
1077 Scav = LoongArch::R20;
1078 int FrameIndex = LAFI->getBranchRelaxationSpillFrameIndex();
1079 if (FrameIndex == -1)
1080 report_fatal_error("The function size is incorrectly estimated.");
1081 storeRegToStackSlot(MBB, PCAI, Scav, /*IsKill=*/true, FrameIndex,
1082 &LoongArch::GPRRegClass, Register());
1083 TRI->eliminateFrameIndex(std::prev(PCAI->getIterator()),
1084 /*SpAdj=*/0, /*FIOperandNum=*/1);
1085 PCAI->getOperand(1).setMBB(&RestoreBB);
1086 if (Has32S)
1087 ADDI->getOperand(2).setMBB(&RestoreBB);
1088 loadRegFromStackSlot(RestoreBB, RestoreBB.end(), Scav, FrameIndex,
1089 &LoongArch::GPRRegClass, Register());
1090 TRI->eliminateFrameIndex(RestoreBB.back(),
1091 /*SpAdj=*/0, /*FIOperandNum=*/1);
1092 }
1093 MRI.replaceRegWith(ScratchReg, Scav);
1094 MRI.clearVirtRegs();
1095}
1096
1097static unsigned getOppositeBranchOpc(unsigned Opc) {
1098 switch (Opc) {
1099 default:
1100 llvm_unreachable("Unrecognized conditional branch");
1101 case LoongArch::BEQ:
1102 return LoongArch::BNE;
1103 case LoongArch::BNE:
1104 return LoongArch::BEQ;
1105 case LoongArch::BEQZ:
1106 return LoongArch::BNEZ;
1107 case LoongArch::BNEZ:
1108 return LoongArch::BEQZ;
1109 case LoongArch::BCEQZ:
1110 return LoongArch::BCNEZ;
1111 case LoongArch::BCNEZ:
1112 return LoongArch::BCEQZ;
1113 case LoongArch::BLT:
1114 return LoongArch::BGE;
1115 case LoongArch::BGE:
1116 return LoongArch::BLT;
1117 case LoongArch::BLTU:
1118 return LoongArch::BGEU;
1119 case LoongArch::BGEU:
1120 return LoongArch::BLTU;
1121 }
1122}
1123
1126 assert((Cond.size() && Cond.size() <= 3) && "Invalid branch condition!");
1127 Cond[0].setImm(getOppositeBranchOpc(Cond[0].getImm()));
1128 return false;
1129}
1130
1131std::pair<unsigned, unsigned>
1133 const unsigned Mask = LoongArchII::MO_DIRECT_FLAG_MASK;
1134 return std::make_pair(TF & Mask, TF & ~Mask);
1135}
1136
1139 using namespace LoongArchII;
1140 // TODO: Add more target flags.
1141 static const std::pair<unsigned, const char *> TargetFlags[] = {
1142 {MO_CALL, "loongarch-call"},
1143 {MO_CALL_PLT, "loongarch-call-plt"},
1144 {MO_PCREL_HI, "loongarch-pcrel-hi"},
1145 {MO_PCREL_LO, "loongarch-pcrel-lo"},
1146 {MO_PCREL64_LO, "loongarch-pcrel64-lo"},
1147 {MO_PCREL64_HI, "loongarch-pcrel64-hi"},
1148 {MO_GOT_PC_HI, "loongarch-got-pc-hi"},
1149 {MO_GOT_PC_LO, "loongarch-got-pc-lo"},
1150 {MO_GOT_PC64_LO, "loongarch-got-pc64-lo"},
1151 {MO_GOT_PC64_HI, "loongarch-got-pc64-hi"},
1152 {MO_LE_HI, "loongarch-le-hi"},
1153 {MO_LE_LO, "loongarch-le-lo"},
1154 {MO_LE64_LO, "loongarch-le64-lo"},
1155 {MO_LE64_HI, "loongarch-le64-hi"},
1156 {MO_IE_PC_HI, "loongarch-ie-pc-hi"},
1157 {MO_IE_PC_LO, "loongarch-ie-pc-lo"},
1158 {MO_IE_PC64_LO, "loongarch-ie-pc64-lo"},
1159 {MO_IE_PC64_HI, "loongarch-ie-pc64-hi"},
1160 {MO_LD_PC_HI, "loongarch-ld-pc-hi"},
1161 {MO_GD_PC_HI, "loongarch-gd-pc-hi"},
1162 {MO_CALL30, "loongarch-call30"},
1163 {MO_CALL36, "loongarch-call36"},
1164 {MO_DESC_PC_HI, "loongarch-desc-pc-hi"},
1165 {MO_DESC_PC_LO, "loongarch-desc-pc-lo"},
1166 {MO_DESC64_PC_LO, "loongarch-desc64-pc-lo"},
1167 {MO_DESC64_PC_HI, "loongarch-desc64-pc-hi"},
1168 {MO_DESC_LD, "loongarch-desc-ld"},
1169 {MO_DESC_CALL, "loongarch-desc-call"},
1170 {MO_LE_HI_R, "loongarch-le-hi-r"},
1171 {MO_LE_ADD_R, "loongarch-le-add-r"},
1172 {MO_LE_LO_R, "loongarch-le-lo-r"},
1173 {MO_PCADD_HI, "loongarch-pcadd-hi"},
1174 {MO_PCADD_LO, "loongarch-pcadd-lo"},
1175 {MO_GOT_PCADD_HI, "loongarch-got-pcadd-hi"},
1176 {MO_GOT_PCADD_LO, "loongarch-got-pcadd-lo"},
1177 {MO_IE_PCADD_HI, "loongarch-ie-pcadd-hi"},
1178 {MO_IE_PCADD_LO, "loongarch-ie-pcadd-lo"},
1179 {MO_LD_PCADD_HI, "loongarch-ld-pcadd-hi"},
1180 {MO_LD_PCADD_LO, "loongarch-ld-pcadd-lo"},
1181 {MO_GD_PCADD_HI, "loongarch-gd-pcadd-hi"},
1182 {MO_GD_PCADD_LO, "loongarch-gd-pcadd-lo"},
1183 {MO_DESC_PCADD_HI, "loongarch-pcadd-desc-hi"},
1184 {MO_DESC_PCADD_LO, "loongarch-pcadd-desc-lo"}};
1185 return ArrayRef(TargetFlags);
1186}
1187
1190 using namespace LoongArchII;
1191 static const std::pair<unsigned, const char *> TargetFlags[] = {
1192 {MO_RELAX, "loongarch-relax"}};
1193 return ArrayRef(TargetFlags);
1194}
1195
1197 Register Reg,
1198 const MachineInstr &AddrI,
1199 ExtAddrMode &AM) const {
1200 enum MemIOffsetType {
1201 Imm14Shift2,
1202 Imm12,
1203 Imm11Shift1,
1204 Imm10Shift2,
1205 Imm9Shift3,
1206 Imm8,
1207 Imm8Shift1,
1208 Imm8Shift2,
1209 Imm8Shift3
1210 };
1211
1212 MemIOffsetType OT;
1213 switch (MemI.getOpcode()) {
1214 default:
1215 return false;
1216 case LoongArch::LDPTR_W:
1217 case LoongArch::LDPTR_D:
1218 case LoongArch::STPTR_W:
1219 case LoongArch::STPTR_D:
1220 OT = Imm14Shift2;
1221 break;
1222 case LoongArch::LD_B:
1223 case LoongArch::LD_H:
1224 case LoongArch::LD_W:
1225 case LoongArch::LD_D:
1226 case LoongArch::LD_BU:
1227 case LoongArch::LD_HU:
1228 case LoongArch::LD_WU:
1229 case LoongArch::ST_B:
1230 case LoongArch::ST_H:
1231 case LoongArch::ST_W:
1232 case LoongArch::ST_D:
1233 case LoongArch::FLD_S:
1234 case LoongArch::FLD_D:
1235 case LoongArch::FST_S:
1236 case LoongArch::FST_D:
1237 case LoongArch::VLD:
1238 case LoongArch::VST:
1239 case LoongArch::XVLD:
1240 case LoongArch::XVST:
1241 case LoongArch::VLDREPL_B:
1242 case LoongArch::XVLDREPL_B:
1243 OT = Imm12;
1244 break;
1245 case LoongArch::VLDREPL_H:
1246 case LoongArch::XVLDREPL_H:
1247 OT = Imm11Shift1;
1248 break;
1249 case LoongArch::VLDREPL_W:
1250 case LoongArch::XVLDREPL_W:
1251 OT = Imm10Shift2;
1252 break;
1253 case LoongArch::VLDREPL_D:
1254 case LoongArch::XVLDREPL_D:
1255 OT = Imm9Shift3;
1256 break;
1257 case LoongArch::VSTELM_B:
1258 case LoongArch::XVSTELM_B:
1259 OT = Imm8;
1260 break;
1261 case LoongArch::VSTELM_H:
1262 case LoongArch::XVSTELM_H:
1263 OT = Imm8Shift1;
1264 break;
1265 case LoongArch::VSTELM_W:
1266 case LoongArch::XVSTELM_W:
1267 OT = Imm8Shift2;
1268 break;
1269 case LoongArch::VSTELM_D:
1270 case LoongArch::XVSTELM_D:
1271 OT = Imm8Shift3;
1272 break;
1273 }
1274
1275 if (MemI.getOperand(0).getReg() == Reg)
1276 return false;
1277
1278 if ((AddrI.getOpcode() != LoongArch::ADDI_W &&
1279 AddrI.getOpcode() != LoongArch::ADDI_D) ||
1280 !AddrI.getOperand(1).isReg() || !AddrI.getOperand(2).isImm())
1281 return false;
1282
1283 int64_t OldOffset = MemI.getOperand(2).getImm();
1284 int64_t Disp = AddrI.getOperand(2).getImm();
1285 int64_t NewOffset = OldOffset + Disp;
1286 if (!STI.is64Bit())
1287 NewOffset = SignExtend64<32>(NewOffset);
1288
1289 if (!(OT == Imm14Shift2 && isShiftedInt<14, 2>(NewOffset) && STI.hasUAL()) &&
1290 !(OT == Imm12 && isInt<12>(NewOffset)) &&
1291 !(OT == Imm11Shift1 && isShiftedInt<11, 1>(NewOffset)) &&
1292 !(OT == Imm10Shift2 && isShiftedInt<10, 2>(NewOffset)) &&
1293 !(OT == Imm9Shift3 && isShiftedInt<9, 3>(NewOffset)) &&
1294 !(OT == Imm8 && isInt<8>(NewOffset)) &&
1295 !(OT == Imm8Shift1 && isShiftedInt<8, 1>(NewOffset)) &&
1296 !(OT == Imm8Shift2 && isShiftedInt<8, 2>(NewOffset)) &&
1297 !(OT == Imm8Shift3 && isShiftedInt<8, 3>(NewOffset)))
1298 return false;
1299
1300 AM.BaseReg = AddrI.getOperand(1).getReg();
1301 AM.ScaledReg = 0;
1302 AM.Scale = 0;
1303 AM.Displacement = NewOffset;
1305 return true;
1306}
1307
1310 const ExtAddrMode &AM) const {
1311 const DebugLoc &DL = MemI.getDebugLoc();
1312 MachineBasicBlock &MBB = *MemI.getParent();
1313
1314 assert(AM.ScaledReg == 0 && AM.Scale == 0 &&
1315 "Addressing mode not supported for folding");
1316
1317 unsigned MemIOp = MemI.getOpcode();
1318 switch (MemIOp) {
1319 default:
1320 return BuildMI(MBB, MemI, DL, get(MemIOp))
1321 .addReg(MemI.getOperand(0).getReg(), getDefRegState(MemI.mayLoad()))
1322 .addReg(AM.BaseReg)
1323 .addImm(AM.Displacement)
1324 .setMemRefs(MemI.memoperands())
1325 .setMIFlags(MemI.getFlags());
1326 case LoongArch::VSTELM_B:
1327 case LoongArch::VSTELM_H:
1328 case LoongArch::VSTELM_W:
1329 case LoongArch::VSTELM_D:
1330 case LoongArch::XVSTELM_B:
1331 case LoongArch::XVSTELM_H:
1332 case LoongArch::XVSTELM_W:
1333 case LoongArch::XVSTELM_D:
1334 return BuildMI(MBB, MemI, DL, get(MemIOp))
1335 .addReg(MemI.getOperand(0).getReg())
1336 .addReg(AM.BaseReg)
1337 .addImm(AM.Displacement)
1338 .addImm(MemI.getOperand(3).getImm())
1339 .setMemRefs(MemI.memoperands())
1340 .setMIFlags(MemI.getFlags());
1341 }
1342}
1343
1344// Returns true if this is the sext.w pattern, addi.w rd, rs, 0.
1346 return MI.getOpcode() == LoongArch::ADDI_W && MI.getOperand(1).isReg() &&
1347 MI.getOperand(2).isImm() && MI.getOperand(2).getImm() == 0;
1348}
static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target, SmallVectorImpl< MachineOperand > &Cond)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock & MBB
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
static unsigned getOppositeBranchOpc(unsigned Opcode)
IRTranslator LLVM IR MI
static cl::opt< bool > DisableRelocSched("loongarch-disable-reloc-sched", cl::desc("Disable scheduling of instructions with target flags"), cl::init(false), cl::Hidden)
static int getJumpTableIndexFromReg(const MachineRegisterInfo &MRI, Register Reg)
static int getJumpTableIndexFromLoadAddr(const MachineRegisterInfo &MRI, Register Reg)
static bool isJumpTableLoad(const MachineInstr &MI)
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
Register Reg
Register const TargetRegisterInfo * TRI
Promote Memory to Register
Definition Mem2Reg.cpp:110
uint64_t IntrinsicInst * II
SmallVector< MachineOperand, 4 > Cond
MachineRegisterInfo & MRI
const SmallVectorImpl< MachineOperand > MachineBasicBlock * TBB
This file declares the machine register scavenger class.
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
Definition Value.cpp:479
Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:40
A debug info location.
Definition DebugLoc.h:126
void copyPhysReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, Register DstReg, Register SrcReg, bool KillSrc, bool RenamableDest=false, bool RenamableSrc=false) const override
bool isAssociativeAndCommutative(const MachineInstr &Inst, bool Invert) const override
ArrayRef< std::pair< unsigned, const char * > > getSerializableBitmaskMachineOperandTargetFlags() const override
const LoongArchSubtarget & STI
bool reverseBranchCondition(SmallVectorImpl< MachineOperand > &Cond) const override
int getJumpTableIndex(const MachineInstr &MI) const override
bool isSafeToMove(const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const override
bool analyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB, MachineBasicBlock *&FBB, SmallVectorImpl< MachineOperand > &Cond, bool AllowModify) const override
void storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register SrcReg, bool IsKill, int FrameIndex, const TargetRegisterClass *RC, Register VReg, MachineInstr::MIFlag Flags=MachineInstr::NoFlags) const override
std::pair< unsigned, unsigned > decomposeMachineOperandsTargetFlags(unsigned TF) const override
bool isAsCheapAsAMove(const MachineInstr &MI) const override
MCInst getNop() const override
LoongArchInstrInfo(const LoongArchSubtarget &STI)
ArrayRef< std::pair< unsigned, const char * > > getSerializableDirectMachineOperandTargetFlags() const override
unsigned removeBranch(MachineBasicBlock &MBB, int *BytesRemoved=nullptr) const override
Register isLoadFromStackSlot(const MachineInstr &MI, int &FrameIndex) const override
void movImm(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, Register DstReg, uint64_t Val, MachineInstr::MIFlag Flag=MachineInstr::NoFlags) const
unsigned insertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB, MachineBasicBlock *FBB, ArrayRef< MachineOperand > Cond, const DebugLoc &dl, int *BytesAdded=nullptr) const override
void insertIndirectBranch(MachineBasicBlock &MBB, MachineBasicBlock &NewDestBB, MachineBasicBlock &RestoreBB, const DebugLoc &DL, int64_t BrOffset, RegScavenger *RS) const override
std::optional< unsigned > getInverseOpcode(unsigned Opcode) const override
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register DstReg, int FrameIndex, const TargetRegisterClass *RC, Register VReg, unsigned SubReg=0, MachineInstr::MIFlag Flags=MachineInstr::NoFlags) const override
Register isStoreToStackSlot(const MachineInstr &MI, int &FrameIndex) const override
bool isSchedulingBoundary(const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const override
bool isBranchOffsetInRange(unsigned BranchOpc, int64_t BrOffset) const override
bool canFoldIntoAddrMode(const MachineInstr &MemI, Register Reg, const MachineInstr &AddrI, ExtAddrMode &AM) const override
unsigned getInstSizeInBytes(const MachineInstr &MI) const override
MachineBasicBlock * getBranchDestBlock(const MachineInstr &MI) const override
MachineInstr * emitLdStWithAddr(MachineInstr &MemI, const ExtAddrMode &AM) const override
LoongArchMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private Lo...
This class is intended to be used as a base class for asm properties and features specific to the tar...
Definition MCAsmInfo.h:67
LLVM_ABI MCSymbol * createNamedTempSymbol()
Create a temporary symbol with a unique name whose name cannot be omitted in the symbol table.
MCInstBuilder & addReg(MCRegister Reg)
Add a new register operand.
MCInstBuilder & addImm(int64_t Val)
Add a new integer immediate operand.
Instances of this class represent a single low-level machine instruction.
Definition MCInst.h:188
Describe properties that are true of each instruction in the target description file.
bool isConditionalBranch() const
Return true if this is a branch which may fall through to the next instruction or may transfer contro...
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition MCSymbol.h:42
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
Align getObjectAlign(int ObjectIdx) const
Return the alignment of the specified stack object.
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MCContext & getContext() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags F, LLT MemTy, Align BaseAlignment, const MMOMetadata &Metadata=MMOMetadata(), SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)
getMachineMemOperand - Allocate a new MachineMemOperand.
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & setMemRefs(ArrayRef< MachineMemOperand * > MMOs) const
const MachineInstrBuilder & addReg(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a new virtual register operand.
const MachineInstrBuilder & setMIFlag(MachineInstr::MIFlag Flag) const
const MachineInstrBuilder & addImm(int64_t Val) const
Add a new immediate operand.
const MachineInstrBuilder & add(const MachineOperand &MO) const
const MachineInstrBuilder & addSym(MCSymbol *Sym, unsigned char TargetFlags=0) const
const MachineInstrBuilder & addFrameIndex(int Idx) const
const MachineInstrBuilder & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
const MachineInstrBuilder & setMIFlags(unsigned Flags) const
const MachineInstrBuilder & addMemOperand(MachineMemOperand *MMO) const
reverse_iterator getReverse() const
Get a reverse iterator to the same node.
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const MachineBasicBlock * getParent() const
LLVM_ABI void setPreInstrSymbol(MachineFunction &MF, MCSymbol *Symbol)
Set a symbol that will be emitted just prior to the instruction itself.
bool getFlag(MIFlag Flag) const
Return whether an MI flag is set.
LLVM_ABI unsigned getNumExplicitOperands() const
Returns the number of non-implicit operands.
bool mayLoad(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read memory.
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
ArrayRef< MachineMemOperand * > memoperands() const
Access to memory operands of the instruction.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
uint32_t getFlags() const
Return the MI flags bitvector.
A description of a memory reference used in the backend.
@ MOLoad
The memory access reads data.
@ MOStore
The memory access writes data.
MachineOperand class - Representation of each machine instruction operand.
int64_t getImm() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
MachineBasicBlock * getMBB() const
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
void setMBB(MachineBasicBlock *MBB)
static MachineOperand CreateImm(int64_t Val)
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
Wrapper class representing virtual and physical registers.
Definition Register.h:20
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
MI-level Statepoint operands.
Definition StackMaps.h:159
uint32_t getNumPatchBytes() const
Return the number of patchable bytes the given statepoint should emit.
Definition StackMaps.h:208
virtual bool isSchedulingBoundary(const MachineInstr &MI, const MachineBasicBlock *MBB, const MachineFunction &MF) const
Test if the given instruction should be considered a scheduling boundary.
const MCAsmInfo & getMCAsmInfo() const
Return target specific asm information.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetRegisterInfo * getRegisterInfo() const =0
Return the target's register information.
Target - Wrapper for Target specific information.
static constexpr TypeSize getFixed(ScalarTy ExactSize)
Definition TypeSize.h:352
static constexpr TypeSize getZero()
Definition TypeSize.h:358
self_iterator getIterator()
Definition ilist_node.h:123
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static unsigned getDirectFlags(const MachineOperand &MO)
InstSeq generateInstSeq(int64_t Val)
bool isSEXT_W(const MachineInstr &MI)
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
constexpr bool isInt(int64_t x)
Checks if an integer fits into the given bit width.
Definition MathExtras.h:166
@ Kill
The last use of a register.
constexpr RegState getKillRegState(bool B)
Op::Description Desc
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1762
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
decltype(auto) get(const PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > &Pair)
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:163
constexpr RegState getDefRegState(bool B)
ArrayRef(const T &OneElt) -> ArrayRef< T >
constexpr bool isShiftedInt(int64_t x)
Checks if a signed integer is an N bit number shifted left by S.
Definition MathExtras.h:183
constexpr int64_t SignExtend64(uint64_t x)
Sign-extend the number in the bottom B bits of X to a 64-bit integer.
Definition MathExtras.h:572
MCRegisterClass TargetRegisterClass
Definition FastISel.h:58
Used to describe addressing mode similar to ExtAddrMode in CodeGenPrepare.
static LLVM_ABI MachinePointerInfo getFixedStack(MachineFunction &MF, int FI, int64_t Offset=0)
Return a MachinePointerInfo record that refers to the specified FrameIndex.