28 "loongarch-disable-reloc-sched",
29 cl::desc(
"Disable scheduling of instructions with target flags"),
32#define GET_INSTRINFO_CTOR_DTOR
33#include "LoongArchGenInstrInfo.inc"
52 bool RenamableSrc)
const {
53 if (LoongArch::GPRRegClass.
contains(DstReg, SrcReg)) {
61 if (LoongArch::LSX128RegClass.
contains(DstReg, SrcReg)) {
69 if (LoongArch::LASX256RegClass.
contains(DstReg, SrcReg)) {
77 if (LoongArch::CFRRegClass.
contains(DstReg) &&
78 LoongArch::GPRRegClass.
contains(SrcReg)) {
84 if (LoongArch::GPRRegClass.
contains(DstReg) &&
85 LoongArch::CFRRegClass.
contains(SrcReg)) {
91 if (LoongArch::CFRRegClass.
contains(DstReg, SrcReg)) {
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)) {
106 Opc = LoongArch::MOVFR2GR_S;
107 }
else if (LoongArch::GPRRegClass.
contains(DstReg) &&
108 LoongArch::FPR64RegClass.
contains(SrcReg)) {
110 Opc = LoongArch::MOVFR2GR_D;
129 if (LoongArch::GPRRegClass.hasSubClassEq(RC))
130 Opcode =
TRI.getRegSizeInBits(LoongArch::GPRRegClass) == 32
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;
165 DL =
I->getDebugLoc();
168 if (LoongArch::GPRRegClass.hasSubClassEq(RC))
169 Opcode = RegInfo.getRegSizeInBits(LoongArch::GPRRegClass) == 32
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;
196 int &FrameIndex)
const {
204 switch (
MI.getOpcode()) {
207 case LoongArch::LD_W:
208 case LoongArch::FLD_S:
211 case LoongArch::LD_D:
212 case LoongArch::FLD_D:
218 case LoongArch::XVLD:
223 if ((
MI.getOperand(1).isFI()) &&
224 (
MI.getOperand(2).isImm()) &&
225 (
MI.getOperand(2).getImm() == 0)) {
226 FrameIndex =
MI.getOperand(1).getIndex();
227 return MI.getOperand(0).getReg();
234 int &FrameIndex)
const {
242 switch (
MI.getOpcode()) {
245 case LoongArch::ST_W:
246 case LoongArch::FST_S:
249 case LoongArch::ST_D:
250 case LoongArch::FST_D:
256 case LoongArch::XVST:
261 if ((
MI.getOperand(1).isFI()) &&
262 (
MI.getOperand(2).isImm()) &&
263 (
MI.getOperand(2).getImm() == 0)) {
264 FrameIndex =
MI.getOperand(1).getIndex();
265 return MI.getOperand(0).getReg();
283 for (
auto &Inst : Seq) {
285 case LoongArch::LU12I_W:
290 case LoongArch::ADDI_W:
292 case LoongArch::LU32I_D:
293 case LoongArch::LU52I_D:
294 case LoongArch::SLLI_D:
300 case LoongArch::BSTRINS_D:
309 assert(
false &&
"Unknown insn emitted by LoongArchMatInt");
318 unsigned Opcode =
MI.getOpcode();
320 if (Opcode == TargetOpcode::INLINEASM ||
321 Opcode == TargetOpcode::INLINEASM_BR) {
324 return getInlineAsmLength(
MI.getOperand(0).getSymbolName(), MAI);
327 unsigned NumBytes = 0;
333 switch (
Desc.getOpcode()) {
335 return Desc.getSize();
336 case TargetOpcode::STATEPOINT:
338 assert(NumBytes % 4 == 0 &&
"Invalid number of NOP bytes requested!");
343 case TargetOpcode::PATCHABLE_FUNCTION_ENTER: {
346 if (
F.hasFnAttribute(
"patchable-function-entry")) {
348 F.getFnAttributeAsParsedInteger(
"patchable-function-entry");
353 case TargetOpcode::PATCHABLE_FUNCTION_EXIT:
354 case TargetOpcode::PATCHABLE_TAIL_CALL:
357 case TargetOpcode::BUNDLE:
358 return getInstBundleSize(
MI);
364 const unsigned Opcode =
MI.getOpcode();
368 case LoongArch::ADDI_D:
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);
375 return MI.isAsCheapAsAMove();
380 const PseudoSourceValue *PSV = MMO->getPseudoValue();
381 return PSV && PSV->isJumpTable();
389 if (!
Reg.isVirtual())
396 switch (
MI->getOpcode()) {
397 case LoongArch::ADDI_D:
398 case LoongArch::ADDI_W:
399 case LoongArch::PseudoLA_PCREL:
402 return MO.getIndex();
404 case LoongArch::LDX_D:
405 case LoongArch::LDX_W:
425 if (!
Reg.isVirtual())
432 switch (
MI->getOpcode()) {
433 case LoongArch::ADD_W:
441 case LoongArch::ALSL_W:
460 if (
MI.getOpcode() != LoongArch::PseudoBRIND)
464 if (!Reg.isVirtual())
473 switch (Def->getOpcode()) {
474 case LoongArch::LD_W:
482 case LoongArch::ADD_D:
483 case LoongArch::ADD_W:
500 Opc = *InverseOpcode;
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:
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:
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:
604std::optional<unsigned>
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;
678 assert(
MI.getDesc().isBranch() &&
"Unexpected opcode!");
680 return MI.getOperand(
MI.getNumExplicitOperands() - 1).getMBB();
687 "Unknown conditional branch");
692 for (
int i = 0; i < NumOp - 1; i++)
700 bool AllowModify)
const {
706 if (
I ==
MBB.end() || !isUnpredicatedTerminator(*
I))
712 int NumTerminators = 0;
713 for (
auto J =
I.getReverse(); J !=
MBB.rend() && isUnpredicatedTerminator(*J);
716 if (J->getDesc().isUnconditionalBranch() ||
717 J->getDesc().isIndirectBranch()) {
724 if (AllowModify && FirstUncondOrIndirectBr !=
MBB.end()) {
725 while (std::next(FirstUncondOrIndirectBr) !=
MBB.end()) {
726 std::next(FirstUncondOrIndirectBr)->eraseFromParent();
729 I = FirstUncondOrIndirectBr;
733 if (NumTerminators == 1 &&
I->getDesc().isUnconditionalBranch()) {
739 if (NumTerminators == 1 &&
I->getDesc().isConditionalBranch()) {
745 if (NumTerminators == 2 && std::prev(
I)->getDesc().isConditionalBranch() &&
746 I->getDesc().isUnconditionalBranch()) {
757 int64_t BrOffset)
const {
765 case LoongArch::BLTU:
766 case LoongArch::BGEU:
768 case LoongArch::BEQZ:
769 case LoongArch::BNEZ:
770 case LoongArch::BCEQZ:
771 case LoongArch::BCNEZ:
774 case LoongArch::PseudoBR:
784 if (MO.getTargetFlags())
788 auto MII =
MI.getIterator();
789 auto MIE =
MBB->end();
820 switch (
MI.getOpcode()) {
821 case LoongArch::PCALAU12I: {
822 auto AddI = std::next(MII);
823 if (AddI == MIE || AddI->getOpcode() != LoongArch::ADDI_D)
825 auto Lu32I = std::next(AddI);
826 if (Lu32I == MIE || Lu32I->getOpcode() != LoongArch::LU32I_D)
828 auto MO0 =
MI.getOperand(1).getTargetFlags();
829 auto MO1 = AddI->getOperand(2).getTargetFlags();
830 auto MO2 = Lu32I->getOperand(2).getTargetFlags();
847 case LoongArch::LU52I_D: {
848 auto MO =
MI.getOperand(2).getTargetFlags();
859 if (
STI.hasFeature(LoongArch::FeatureRelax)) {
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: {
881 auto SecondOp = std::next(MII);
883 if (SecondOp == MIE || SecondOp->getOpcode() != AddiOp)
885 auto Ld = std::next(SecondOp);
886 if (Ld == MIE || Ld->getOpcode() != LdOp)
894 if (SecondOp == MIE ||
895 (SecondOp->getOpcode() != AddiOp && SecondOp->getOpcode() != LdOp))
910 case LoongArch::ADDI_W:
911 case LoongArch::ADDI_D: {
917 case LoongArch::LD_W:
918 case LoongArch::LD_D: {
924 case LoongArch::PseudoDESC_CALL: {
951 int *BytesRemoved)
const {
958 if (!
I->getDesc().isBranch())
964 I->eraseFromParent();
968 if (
I ==
MBB.begin())
971 if (!
I->getDesc().isConditionalBranch())
977 I->eraseFromParent();
990 assert(
TBB &&
"insertBranch must not be told to insert a fallthrough");
992 "LoongArch branch conditions have at most two components!");
1004 for (
unsigned i = 1; i <
Cond.size(); ++i)
1027 assert(RS &&
"RegScavenger required for long branching");
1029 "new block should be inserted for expanding unconditional branch");
1037 bool Has32S =
STI.hasFeature(LoongArch::Feature32S);
1041 "Branch offsets outside of the signed 32-bit range not supported");
1043 Register ScratchReg =
MRI.createVirtualRegister(&LoongArch::GPRRegClass);
1046 auto II =
MBB.end();
1047 unsigned ADDIOp =
STI.is64Bit() ? LoongArch::ADDI_D : LoongArch::ADDI_W;
1068 RS->enterBasicBlockEnd(
MBB);
1069 Register Scav = RS->scavengeRegisterBackwards(
1070 LoongArch::GPRRegClass, PCAI->
getIterator(),
false,
1072 if (Scav != LoongArch::NoRegister)
1073 RS->setRegUsed(Scav);
1077 Scav = LoongArch::R20;
1079 if (FrameIndex == -1)
1082 &LoongArch::GPRRegClass,
Register());
1089 &LoongArch::GPRRegClass,
Register());
1090 TRI->eliminateFrameIndex(RestoreBB.
back(),
1093 MRI.replaceRegWith(ScratchReg, Scav);
1094 MRI.clearVirtRegs();
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;
1126 assert((
Cond.size() &&
Cond.size() <= 3) &&
"Invalid branch condition!");
1131std::pair<unsigned, unsigned>
1134 return std::make_pair(TF & Mask, TF & ~Mask);
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"}};
1191 static const std::pair<unsigned, const char *> TargetFlags[] = {
1192 {MO_RELAX,
"loongarch-relax"}};
1200 enum MemIOffsetType {
1216 case LoongArch::LDPTR_W:
1217 case LoongArch::LDPTR_D:
1218 case LoongArch::STPTR_W:
1219 case LoongArch::STPTR_D:
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:
1245 case LoongArch::VLDREPL_H:
1246 case LoongArch::XVLDREPL_H:
1249 case LoongArch::VLDREPL_W:
1250 case LoongArch::XVLDREPL_W:
1253 case LoongArch::VLDREPL_D:
1254 case LoongArch::XVLDREPL_D:
1257 case LoongArch::VSTELM_B:
1258 case LoongArch::XVSTELM_B:
1261 case LoongArch::VSTELM_H:
1262 case LoongArch::XVSTELM_H:
1265 case LoongArch::VSTELM_W:
1266 case LoongArch::XVSTELM_W:
1269 case LoongArch::VSTELM_D:
1270 case LoongArch::XVSTELM_D:
1278 if ((AddrI.
getOpcode() != LoongArch::ADDI_W &&
1279 AddrI.
getOpcode() != LoongArch::ADDI_D) ||
1285 int64_t NewOffset = OldOffset + Disp;
1290 !(OT == Imm12 &&
isInt<12>(NewOffset)) &&
1294 !(OT == Imm8 &&
isInt<8>(NewOffset)) &&
1315 "Addressing mode not supported for folding");
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:
1346 return MI.getOpcode() == LoongArch::ADDI_W &&
MI.getOperand(1).isReg() &&
1347 MI.getOperand(2).isImm() &&
MI.getOperand(2).getImm() == 0;
static void parseCondBranch(MachineInstr *LastInst, MachineBasicBlock *&Target, SmallVectorImpl< MachineOperand > &Cond)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
static unsigned getOppositeBranchOpc(unsigned Opcode)
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)
Register const TargetRegisterInfo * TRI
Promote Memory to Register
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)
Represent a constant reference to an array (0 or more elements consecutively in memory),...
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...
int getBranchRelaxationSpillFrameIndex()
This class is intended to be used as a base class for asm properties and features specific to the tar...
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.
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 ...
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.
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.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
MI-level Statepoint operands.
uint32_t getNumPatchBytes() const
Return the number of patchable bytes the given statepoint should emit.
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)
static constexpr TypeSize getZero()
self_iterator getIterator()
#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.
@ Kill
The last use of a register.
constexpr RegState getKillRegState(bool B)
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
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)
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.
constexpr int64_t SignExtend64(uint64_t x)
Sign-extend the number in the bottom B bits of X to a 64-bit integer.
MCRegisterClass TargetRegisterClass
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.