Lines Matching refs:RISCV
1 //===-- RISCVISelLowering.cpp - RISCV DAG Lowering Implementation --------===//
9 // This file defines the interfaces that RISCV uses to lower LLVM code into a
15 #include "RISCV.h"
84 addRegisterClass(XLenVT, &RISCV::GPRRegClass);
87 addRegisterClass(MVT::f32, &RISCV::FPR32RegClass);
89 addRegisterClass(MVT::f64, &RISCV::FPR64RegClass);
94 setStackPointerRegisterToSaveRestore(RISCV::X2);
411 return RISCV::BEQ;
413 return RISCV::BNE;
415 return RISCV::BLT;
417 return RISCV::BGE;
419 return RISCV::BLTU;
421 return RISCV::BGEU;
497 return SDValue(DAG.getMachineNode(RISCV::PseudoLLA, DL, Ty, Addr), 0);
502 return SDValue(DAG.getMachineNode(RISCV::PseudoLA, DL, Ty, Addr), 0);
513 SDValue MNHi = SDValue(DAG.getMachineNode(RISCV::LUI, DL, Ty, AddrHi), 0);
514 return SDValue(DAG.getMachineNode(RISCV::ADDI, DL, Ty, MNHi, AddrLo), 0);
521 return SDValue(DAG.getMachineNode(RISCV::PseudoLLA, DL, Ty, Addr), 0);
577 SDValue(DAG.getMachineNode(RISCV::PseudoLA_TLS_IE, DL, Ty, Addr), 0);
580 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
595 SDValue MNHi = SDValue(DAG.getMachineNode(RISCV::LUI, DL, Ty, AddrHi), 0);
596 SDValue TPReg = DAG.getRegister(RISCV::X4, XLenVT);
598 DAG.getMachineNode(RISCV::PseudoAddTPRel, DL, Ty, MNHi, TPReg, AddrAdd),
600 return SDValue(DAG.getMachineNode(RISCV::ADDI, DL, Ty, MNAdd, AddrLo), 0);
615 SDValue(DAG.getMachineNode(RISCV::PseudoLA_TLS_GD, DL, Ty, Addr), 0);
877 return DAG.getRegister(RISCV::X4, PtrVT);
1187 assert(MI.getOpcode() == RISCV::ReadCycleWide && "Unexpected instruction");
1218 Register ReadAgainReg = RegInfo.createVirtualRegister(&RISCV::GPRRegClass);
1224 BuildMI(LoopMBB, DL, TII->get(RISCV::CSRRS), HiReg)
1226 .addReg(RISCV::X0);
1227 BuildMI(LoopMBB, DL, TII->get(RISCV::CSRRS), LoReg)
1229 .addReg(RISCV::X0);
1230 BuildMI(LoopMBB, DL, TII->get(RISCV::CSRRS), ReadAgainReg)
1232 .addReg(RISCV::X0);
1234 BuildMI(LoopMBB, DL, TII->get(RISCV::BNE))
1249 assert(MI.getOpcode() == RISCV::SplitF64Pseudo && "Unexpected instruction");
1258 const TargetRegisterClass *SrcRC = &RISCV::FPR64RegClass;
1266 BuildMI(*BB, MI, DL, TII.get(RISCV::LW), LoReg)
1270 BuildMI(*BB, MI, DL, TII.get(RISCV::LW), HiReg)
1280 assert(MI.getOpcode() == RISCV::BuildPairF64Pseudo &&
1290 const TargetRegisterClass *DstRC = &RISCV::FPR64RegClass;
1296 BuildMI(*BB, MI, DL, TII.get(RISCV::SW))
1301 BuildMI(*BB, MI, DL, TII.get(RISCV::SW))
1315 case RISCV::Select_GPR_Using_CC_GPR:
1316 case RISCV::Select_FPR32_Using_CC_GPR:
1317 case RISCV::Select_FPR64_Using_CC_GPR:
1431 TII.get(RISCV::PHI), SelectMBBI->getOperand(0).getReg())
1451 case RISCV::ReadCycleWide:
1455 case RISCV::Select_GPR_Using_CC_GPR:
1456 case RISCV::Select_FPR32_Using_CC_GPR:
1457 case RISCV::Select_FPR64_Using_CC_GPR:
1459 case RISCV::BuildPairF64Pseudo:
1461 case RISCV::SplitF64Pseudo:
1492 RISCV::X10, RISCV::X11, RISCV::X12, RISCV::X13,
1493 RISCV::X14, RISCV::X15, RISCV::X16, RISCV::X17
1496 RISCV::F10_F, RISCV::F11_F, RISCV::F12_F, RISCV::F13_F,
1497 RISCV::F14_F, RISCV::F15_F, RISCV::F16_F, RISCV::F17_F
1500 RISCV::F10_D, RISCV::F11_D, RISCV::F12_D, RISCV::F13_D,
1501 RISCV::F14_D, RISCV::F15_D, RISCV::F16_D, RISCV::F17_D
1798 RC = &RISCV::GPRRegClass;
1801 RC = &RISCV::FPR32RegClass;
1804 RC = &RISCV::FPR64RegClass;
1886 Register LoVReg = RegInfo.createVirtualRegister(&RISCV::GPRRegClass);
1890 if (VA.getLocReg() == RISCV::X17) {
1898 Register HiVReg = RegInfo.createVirtualRegister(&RISCV::GPRRegClass);
1914 RISCV::X10, RISCV::X11, RISCV::X12, RISCV::X13, RISCV::X14,
1915 RISCV::X15, RISCV::X16, RISCV::X17, RISCV::X7, RISCV::X28,
1916 RISCV::X29, RISCV::X30, RISCV::X31};
1925 RISCV::F10_F, RISCV::F11_F, RISCV::F12_F, RISCV::F13_F, RISCV::F14_F,
1926 RISCV::F15_F, RISCV::F16_F, RISCV::F17_F, RISCV::F0_F, RISCV::F1_F,
1927 RISCV::F2_F, RISCV::F3_F, RISCV::F4_F, RISCV::F5_F, RISCV::F6_F,
1928 RISCV::F7_F, RISCV::F28_F, RISCV::F29_F, RISCV::F30_F, RISCV::F31_F};
1937 RISCV::F10_D, RISCV::F11_D, RISCV::F12_D, RISCV::F13_D, RISCV::F14_D,
1938 RISCV::F15_D, RISCV::F16_D, RISCV::F17_D, RISCV::F0_D, RISCV::F1_D,
1939 RISCV::F2_D, RISCV::F3_D, RISCV::F4_D, RISCV::F5_D, RISCV::F6_D,
1940 RISCV::F7_D, RISCV::F28_D, RISCV::F29_D, RISCV::F30_D, RISCV::F31_D};
2044 const TargetRegisterClass *RC = &RISCV::GPRRegClass;
2267 if (RegLo == RISCV::X17) {
2271 StackPtr = DAG.getCopyFromReg(Chain, DL, RISCV::X2, PtrVT);
2277 assert(RegLo < RISCV::X31 && "Invalid register pair");
2329 StackPtr = DAG.getCopyFromReg(Chain, DL, RISCV::X2, PtrVT);
2357 MF.getSubtarget<RISCVSubtarget>().isRegisterReservedByUser(RISCV::X1))
2508 assert(RegLo < RISCV::X31 && "Invalid register pair");
2658 // RISCV register class.
2662 return std::make_pair(0U, &RISCV::GPRRegClass);
2665 return std::make_pair(0U, &RISCV::FPR32RegClass);
2667 return std::make_pair(0U, &RISCV::FPR64RegClass);
2679 .Case("{zero}", RISCV::X0)
2680 .Case("{ra}", RISCV::X1)
2681 .Case("{sp}", RISCV::X2)
2682 .Case("{gp}", RISCV::X3)
2683 .Case("{tp}", RISCV::X4)
2684 .Case("{t0}", RISCV::X5)
2685 .Case("{t1}", RISCV::X6)
2686 .Case("{t2}", RISCV::X7)
2687 .Cases("{s0}", "{fp}", RISCV::X8)
2688 .Case("{s1}", RISCV::X9)
2689 .Case("{a0}", RISCV::X10)
2690 .Case("{a1}", RISCV::X11)
2691 .Case("{a2}", RISCV::X12)
2692 .Case("{a3}", RISCV::X13)
2693 .Case("{a4}", RISCV::X14)
2694 .Case("{a5}", RISCV::X15)
2695 .Case("{a6}", RISCV::X16)
2696 .Case("{a7}", RISCV::X17)
2697 .Case("{s2}", RISCV::X18)
2698 .Case("{s3}", RISCV::X19)
2699 .Case("{s4}", RISCV::X20)
2700 .Case("{s5}", RISCV::X21)
2701 .Case("{s6}", RISCV::X22)
2702 .Case("{s7}", RISCV::X23)
2703 .Case("{s8}", RISCV::X24)
2704 .Case("{s9}", RISCV::X25)
2705 .Case("{s10}", RISCV::X26)
2706 .Case("{s11}", RISCV::X27)
2707 .Case("{t3}", RISCV::X28)
2708 .Case("{t4}", RISCV::X29)
2709 .Case("{t5}", RISCV::X30)
2710 .Case("{t6}", RISCV::X31)
2711 .Default(RISCV::NoRegister);
2712 if (XRegFromAlias != RISCV::NoRegister)
2713 return std::make_pair(XRegFromAlias, &RISCV::GPRRegClass);
2725 .Cases("{f0}", "{ft0}", {RISCV::F0_F, RISCV::F0_D})
2726 .Cases("{f1}", "{ft1}", {RISCV::F1_F, RISCV::F1_D})
2727 .Cases("{f2}", "{ft2}", {RISCV::F2_F, RISCV::F2_D})
2728 .Cases("{f3}", "{ft3}", {RISCV::F3_F, RISCV::F3_D})
2729 .Cases("{f4}", "{ft4}", {RISCV::F4_F, RISCV::F4_D})
2730 .Cases("{f5}", "{ft5}", {RISCV::F5_F, RISCV::F5_D})
2731 .Cases("{f6}", "{ft6}", {RISCV::F6_F, RISCV::F6_D})
2732 .Cases("{f7}", "{ft7}", {RISCV::F7_F, RISCV::F7_D})
2733 .Cases("{f8}", "{fs0}", {RISCV::F8_F, RISCV::F8_D})
2734 .Cases("{f9}", "{fs1}", {RISCV::F9_F, RISCV::F9_D})
2735 .Cases("{f10}", "{fa0}", {RISCV::F10_F, RISCV::F10_D})
2736 .Cases("{f11}", "{fa1}", {RISCV::F11_F, RISCV::F11_D})
2737 .Cases("{f12}", "{fa2}", {RISCV::F12_F, RISCV::F12_D})
2738 .Cases("{f13}", "{fa3}", {RISCV::F13_F, RISCV::F13_D})
2739 .Cases("{f14}", "{fa4}", {RISCV::F14_F, RISCV::F14_D})
2740 .Cases("{f15}", "{fa5}", {RISCV::F15_F, RISCV::F15_D})
2741 .Cases("{f16}", "{fa6}", {RISCV::F16_F, RISCV::F16_D})
2742 .Cases("{f17}", "{fa7}", {RISCV::F17_F, RISCV::F17_D})
2743 .Cases("{f18}", "{fs2}", {RISCV::F18_F, RISCV::F18_D})
2744 .Cases("{f19}", "{fs3}", {RISCV::F19_F, RISCV::F19_D})
2745 .Cases("{f20}", "{fs4}", {RISCV::F20_F, RISCV::F20_D})
2746 .Cases("{f21}", "{fs5}", {RISCV::F21_F, RISCV::F21_D})
2747 .Cases("{f22}", "{fs6}", {RISCV::F22_F, RISCV::F22_D})
2748 .Cases("{f23}", "{fs7}", {RISCV::F23_F, RISCV::F23_D})
2749 .Cases("{f24}", "{fs8}", {RISCV::F24_F, RISCV::F24_D})
2750 .Cases("{f25}", "{fs9}", {RISCV::F25_F, RISCV::F25_D})
2751 .Cases("{f26}", "{fs10}", {RISCV::F26_F, RISCV::F26_D})
2752 .Cases("{f27}", "{fs11}", {RISCV::F27_F, RISCV::F27_D})
2753 .Cases("{f28}", "{ft8}", {RISCV::F28_F, RISCV::F28_D})
2754 .Cases("{f29}", "{ft9}", {RISCV::F29_F, RISCV::F29_D})
2755 .Cases("{f30}", "{ft10}", {RISCV::F30_F, RISCV::F30_D})
2756 .Cases("{f31}", "{ft11}", {RISCV::F31_F, RISCV::F31_D})
2757 .Default({RISCV::NoRegister, RISCV::NoRegister});
2758 if (FReg.first != RISCV::NoRegister)
2760 ? std::make_pair(FReg.second, &RISCV::FPR64RegClass)
2761 : std::make_pair(FReg.first, &RISCV::FPR32RegClass);
2979 return RISCV::X10;
2984 return RISCV::X11;
3024 if (Reg == RISCV::NoRegister)
3026 if (Reg == RISCV::NoRegister)