34#define DEBUG_TYPE "riscv-frame"
61 RISCV::X18, RISCV::X19, RISCV::X20,
62 RISCV::X21, RISCV::X22, RISCV::X23,
63 RISCV::X24, RISCV::X25, RISCV::X26,
128 "Unexpected Shadow Stack Kind");
132 bool IsRV64 = STI.is64Bit();
133 int64_t SlotSize = STI.getXLen() / 8;
152 char DwarfSCSReg =
TRI->getDwarfRegNum(SCSPReg,
true);
153 assert(DwarfSCSReg < 32 &&
"SCS Register should be < 32 (X3).");
155 char Offset =
static_cast<char>(-SlotSize) & 0x7f;
156 const char CFIInst[] = {
157 dwarf::DW_CFA_val_expression,
160 static_cast<char>(
unsigned(dwarf::DW_OP_breg0 + DwarfSCSReg)),
185 if (
MI !=
MBB.end() &&
186 (
MI->getOpcode() == RISCV::CM_POP ||
MI->getOpcode() == RISCV::QC_CM_POP))
200 "Unexpected Shadow Stack Kind");
204 bool IsRV64 = STI.is64Bit();
205 int64_t SlotSize = STI.getXLen() / 8;
230 if (!RVFI->isSiFiveStackSwapInterrupt(MF))
236 assert(STI.hasVendorXSfmclic() &&
"Stack Swapping Requires XSfmclic");
239 .
addImm(RISCVSysReg::sf_mscratchcsw)
258 for (
int I = 0;
I < 2; ++
I) {
271 assert(ScratchCS != CSI.end() &&
"Missing SiFive CLIC scratch spill slot");
272 return ScratchCS->getFrameIdx();
281 if (!RVFI->isSiFivePreemptibleInterrupt(MF))
292 TII->storeRegToStackSlot(
MBB,
MBBI, RISCV::X5,
true, ScratchFI,
300 .
addImm(RISCVSysReg::mcause)
303 TII->storeRegToStackSlot(
MBB,
MBBI, RISCV::X5,
true,
304 RVFI->getInterruptCSRFrameIndex(0),
309 .
addImm(RISCVSysReg::mepc)
315 .
addImm(RISCVSysReg::mstatus)
318 TII->storeRegToStackSlot(
MBB,
MBBI, RISCV::X5,
true,
319 RVFI->getInterruptCSRFrameIndex(1),
331 if (!RVFI->isSiFivePreemptibleInterrupt(MF))
341 TII->loadRegFromStackSlot(
MBB,
MBBI, RISCV::X5,
342 RVFI->getInterruptCSRFrameIndex(1),
348 .
addImm(RISCVSysReg::mstatus)
355 .
addImm(RISCVSysReg::mepc)
359 TII->loadRegFromStackSlot(
MBB,
MBBI, RISCV::X5,
360 RVFI->getInterruptCSRFrameIndex(0),
364 .
addImm(RISCVSysReg::mcause)
370 TII->loadRegFromStackSlot(
MBB,
MBBI, RISCV::X5,
383 const std::vector<CalleeSavedInfo> &CSI) {
386 if (CSI.empty() || !RVFI->useSaveRestoreLibCalls(MF))
393 if (CS.getFrameIdx() < 0)
394 MaxReg = std::max(MaxReg.
id(), CS.getReg().id());
399 switch (MaxReg.
id()) {
403 case RISCV::X27:
return 12;
404 case RISCV::X26:
return 11;
405 case RISCV::X25:
return 10;
406 case RISCV::X24:
return 9;
407 case RISCV::X23:
return 8;
408 case RISCV::X22:
return 7;
409 case RISCV::X21:
return 6;
410 case RISCV::X20:
return 5;
411 case RISCV::X19:
return 4;
412 case RISCV::X18:
return 3;
413 case RISCV::X9:
return 2;
414 case FPReg:
return 1;
415 case RAReg:
return 0;
424 const std::vector<CalleeSavedInfo> &CSI) {
425 static const char *
const SpillLibCalls[] = {
444 return SpillLibCalls[LibCallID];
451 const std::vector<CalleeSavedInfo> &CSI) {
452 static const char *
const RestoreLibCalls[] = {
463 "__riscv_restore_10",
464 "__riscv_restore_11",
471 return RestoreLibCalls[LibCallID];
476 unsigned NumPushPopRegs = 0;
477 for (
auto &CS : CSI) {
481 unsigned RegNum = std::distance(std::begin(
FixedCSRFIMap), FII);
482 NumPushPopRegs = std::max(NumPushPopRegs, RegNum + 1);
485 assert(NumPushPopRegs != 12 &&
"x26 requires x27 to also be pushed");
486 return NumPushPopRegs;
529 TRI->hasStackRealignment(MF);
533void RISCVFrameLowering::determineFrameLayout(
MachineFunction &MF)
const {
541 if (RVFI->useQCIInterrupt(MF))
548 FrameSize =
alignTo(FrameSize, StackAlign);
558 if (RVFI->getRVVStackSize() && (!
hasFP(MF) ||
TRI->hasStackRealignment(MF))) {
559 int ScalarLocalVarSize = FrameSize - RVFI->getCalleeSavedStackSize() -
560 RVFI->getVarArgsSaveSize();
561 if (
auto RVVPadding =
563 RVFI->setRVVPadding(RVVPadding);
578 const std::vector<CalleeSavedInfo> &CSI,
579 bool ReverseOrder =
false) {
583 for (
auto &CS : CSI) {
584 int FI = CS.getFrameIdx();
587 bool IsManagedFI = (FI < 0);
595 std::reverse(NonLibcallCSI.
begin(), NonLibcallCSI.
end());
597 return NonLibcallCSI;
604 const std::vector<CalleeSavedInfo> &CSI,
605 bool ReverseOrder =
false) {
609 return CS.
getReg() == RISCV::X5;
616 const std::vector<CalleeSavedInfo> &CSI) {
620 for (
auto &CS : CSI) {
621 int FI = CS.getFrameIdx();
631 const std::vector<CalleeSavedInfo> &CSI) {
635 if (!RVFI->useSaveRestoreLibCalls(MF) && !RVFI->isPushable(MF))
636 return PushOrLibCallsCSI;
638 for (
const auto &CS : CSI) {
639 if (RVFI->useQCIInterrupt(MF)) {
650 PushOrLibCallsCSI.push_back(CS);
653 return PushOrLibCallsCSI;
658 const std::vector<CalleeSavedInfo> &CSI) {
662 if (!RVFI->useQCIInterrupt(MF))
663 return QCIInterruptCSI;
665 for (
const auto &CS : CSI) {
668 QCIInterruptCSI.push_back(CS);
671 return QCIInterruptCSI;
679 for (
unsigned i = 0; CSRegs[i]; ++i)
702 static const MCPhysReg CandidateRegs[] = {
703 RISCV::X5, RISCV::X6, RISCV::X7, RISCV::X28,
704 RISCV::X29, RISCV::X30, RISCV::X31,
707 for (
unsigned Reg : CandidateRegs) {
708 if (Reg != DontUseReg &&
LiveRegs.available(
MRI, Reg))
715void RISCVFrameLowering::allocateAndProbeStackForRVV(
719 assert(Amount != 0 &&
"Did not need to adjust stack pointer for RVV.");
726 "No available scratch register for stack probing");
731 TII->mulImm(MF,
MBB,
MBBI,
DL, TargetReg, NumOfVReg, Flag);
736 CFIBuilder.buildDefCFA(TargetReg, -Amount);
745 CFIBuilder.buildDefCFARegister(
SPReg);
768 int64_t FixedOffset =
Offset.getFixed();
769 int64_t ScalableOffset =
Offset.getScalable();
770 unsigned DwarfVLenB =
TRI.getDwarfRegNum(RISCV::VLENB,
true);
775 Comment << (FixedOffset < 0 ?
" - " :
" + ") << std::abs(FixedOffset);
788 Comment << (ScalableOffset < 0 ?
" - " :
" + ") << std::abs(ScalableOffset)
795 assert(
Offset.getScalable() != 0 &&
"Did not need to adjust CFA for RVV");
797 std::string CommentBuffer;
800 unsigned DwarfReg =
TRI.getDwarfRegNum(
Reg,
true);
811 DefCfaExpr.
push_back(dwarf::DW_CFA_def_cfa_expression);
821 assert(
Offset.getScalable() != 0 &&
"Did not need to adjust CFA for RVV");
823 std::string CommentBuffer;
831 unsigned DwarfReg =
TRI.getDwarfRegNum(
Reg,
true);
832 DefCfaExpr.
push_back(dwarf::DW_CFA_expression);
845 uint64_t RealStackSize,
bool EmitCFI,
846 bool NeedProbe, uint64_t ProbeSize,
852 bool IsRV64 =
STI.is64Bit();
856 if (!NeedProbe ||
Offset <= ProbeSize) {
863 if (NeedProbe && DynAllocation) {
876 uint64_t CFAAdjust = RealStackSize -
Offset;
879 if (
Offset < ProbeSize * 5) {
880 uint64_t CurrentOffset = 0;
881 while (CurrentOffset + ProbeSize <=
Offset) {
891 CurrentOffset += ProbeSize;
896 uint64_t Residual =
Offset - CurrentOffset;
918 uint64_t Residual =
Offset - RoundedSize;
922 "No available scratch register for stack probing");
929 CFIBuilder.
buildDefCFA(TargetReg, RoundedSize + CFAAdjust);
960 case RISCV::QC_CM_PUSH:
961 case RISCV::QC_CM_PUSHFP:
973 case RISCV::QC_CM_POP:
984 return RISCV::CM_PUSH;
986 return UpdateFP ? RISCV::QC_CM_PUSHFP : RISCV::QC_CM_PUSH;
997 return RISCV::CM_POP;
999 return RISCV::QC_CM_POP;
1011 bool PreferAscendingLS =
STI.preferAscendingLoadStore();
1033 auto PossiblePush =
MBBI;
1040 determineFrameLayout(MF);
1053 if (
unsigned LibCallFrameSize = RVFI->getLibCallStackSize()) {
1054 if (NeedsDwarfCFI) {
1065 uint64_t StackSize = RealStackSize - RVFI->getReservedSpillsSize();
1066 uint64_t RVVStackSize = RVFI->getRVVStackSize();
1069 if (RealStackSize == 0 && !MFI.
adjustsStack() && RVVStackSize == 0)
1074 if (
STI.isRegisterReservedByUser(
SPReg))
1076 MF.
getFunction(),
"Stack pointer required, but has been reserved."});
1080 if (FirstSPAdjustAmount) {
1081 StackSize = FirstSPAdjustAmount;
1082 RealStackSize = FirstSPAdjustAmount;
1085 if (RVFI->useQCIInterrupt(MF)) {
1090 if (NeedsDwarfCFI) {
1103 if (RVFI->isPushable(MF) && PossiblePush !=
MBB.end() &&
1104 isPush(PossiblePush->getOpcode())) {
1110 std::min(
alignDown(StackSize, 16),
static_cast<uint64_t
>(48));
1111 PossiblePush->getOperand(1).setImm(StackAdj);
1112 StackSize -= StackAdj;
1114 if (NeedsDwarfCFI) {
1125 bool NeedProbe =
TLI->hasInlineStackProbe(MF);
1127 bool DynAllocation =
1131 NeedProbe, ProbeSize, DynAllocation,
1149 if (NeedsDwarfCFI) {
1156 if (RISCV::GPRPairRegClass.
contains(Reg)) {
1157 MCRegister EvenReg = RI->getSubReg(Reg, RISCV::sub_gpr_even);
1158 MCRegister OddReg = RI->getSubReg(Reg, RISCV::sub_gpr_odd);
1169 if (
STI.isRegisterReservedByUser(
FPReg))
1171 MF.
getFunction(),
"Frame pointer required, but has been reserved."});
1177 if (!RVFI->hasImplicitFPUpdates(MF)) {
1188 uint64_t SecondSPAdjustAmount = 0;
1190 if (FirstSPAdjustAmount) {
1192 assert(SecondSPAdjustAmount > 0 &&
1193 "SecondSPAdjustAmount should be greater than zero");
1197 NeedProbe, ProbeSize, DynAllocation,
1203 allocateAndProbeStackForRVV(MF,
MBB,
MBBI,
DL, RVVStackSize,
1205 NeedsDwarfCFI && !
hasFP(MF), DynAllocation);
1214 if (NeedsDwarfCFI && !
hasFP(MF)) {
1229 if (RI->hasStackRealignment(MF)) {
1233 if (
isInt<12>(-(int64_t)MaxAlignment.value())) {
1236 .
addImm(-(int64_t)MaxAlignment.value())
1239 unsigned ShiftAmount =
Log2(MaxAlignment);
1251 if (NeedProbe && RVVStackSize == 0) {
1254 if (SecondSPAdjustAmount < ProbeSize &&
1255 SecondSPAdjustAmount + MaxAlignment.value() >= ProbeSize) {
1256 bool IsRV64 =
STI.is64Bit();
1282 uint64_t &StackSize,
1283 int64_t CFAOffset)
const {
1300 bool PreferAscendingLS =
STI.preferAscendingLoadStore();
1312 MBBI =
MBB.getLastNonDebugInstr();
1314 DL =
MBBI->getDebugLoc();
1316 MBBI =
MBB.getFirstTerminator();
1329 auto FirstScalarCSRRestoreInsn =
1336 uint64_t RealStackSize = FirstSPAdjustAmount ? FirstSPAdjustAmount
1338 uint64_t StackSize = FirstSPAdjustAmount ? FirstSPAdjustAmount
1340 RVFI->getReservedSpillsSize();
1341 uint64_t FPOffset = RealStackSize - RVFI->getVarArgsSaveSize();
1342 uint64_t RVVStackSize = RVFI->getRVVStackSize();
1348 bool CallFrameMovesSP =
1351 bool RestoreSPFromFP =
1358 if (!RestoreSPFromFP)
1363 if (NeedsDwarfCFI) {
1366 emitCalleeSavedRVVEpilogCFI(
MBB, FirstScalarCSRRestoreInsn);
1370 if (FirstSPAdjustAmount) {
1371 uint64_t SecondSPAdjustAmount =
1373 assert(SecondSPAdjustAmount > 0 &&
1374 "SecondSPAdjustAmount should be greater than zero");
1378 if (!RestoreSPFromFP)
1383 if (NeedsDwarfCFI && !
hasFP(MF))
1397 if (RestoreSPFromFP) {
1398 assert(
hasFP(MF) &&
"frame pointer should not have been eliminated");
1404 if (NeedsDwarfCFI &&
hasFP(MF))
1410 MBBI = std::next(FirstScalarCSRRestoreInsn,
1415 auto emitRestoreCFI = [&](
auto CSInfo) {
1416 for (
auto &CS : CSInfo) {
1419 if (RISCV::GPRPairRegClass.
contains(Reg)) {
1420 MCRegister EvenReg = RI->getSubReg(Reg, RISCV::sub_gpr_even);
1421 MCRegister OddReg = RI->getSubReg(Reg, RISCV::sub_gpr_odd);
1430 if (RVFI->useSaveRestoreLibCalls(MF)) {
1431 if (RVFI->hasShadowStack(MF)) {
1436 StackSize += RVFI->getLibCallStackSize();
1444 emitRestoreCFI(LibcallCSI);
1450 deallocateStack(MF,
MBB,
MBBI,
DL, StackSize,
1451 RVFI->getLibCallStackSize());
1463 if (RVFI->isPushable(MF) &&
MBBI !=
MBB.end() &&
isPop(
MBBI->getOpcode())) {
1469 std::min(
alignDown(StackSize, 16),
static_cast<uint64_t
>(48));
1470 MBBI->getOperand(1).setImm(StackAdj);
1471 StackSize -= StackAdj;
1474 deallocateStack(MF,
MBB,
MBBI,
DL, StackSize,
1475 RealStackSize - StackSize);
1478 if (NextI ==
MBB.end() || NextI->getOpcode() != RISCV::PseudoRET) {
1480 if (NeedsDwarfCFI) {
1498 deallocateStack(MF,
MBB,
MBBI,
DL, StackSize,
1499 RVFI->getQCIInterruptStackSize());
1513 std::array<TargetRegisterClass const *, 2> RegisterClasses = {
1514 &RISCV::GPRF16RegClass, &RISCV::GPRF32RegClass};
1515 std::array<unsigned, 2> SubIdx = {RISCV::sub_16, RISCV::sub_32};
1517 for (
auto [RegClass, SubReg] :
zip(RegisterClasses, SubIdx)) {
1518 if (RegClass->contains(
Reg)) {
1520 TRI.getMatchingSuperReg(
Reg, SubReg, &RISCV::GPRRegClass))
1526 "getPhysicalGPR called with unsupported register");
1532 if (!STI.hasStdExtF())
1536 assert(LargestFPRegClass);
1541 std::array<TargetRegisterClass const *, 3> RegisterClasses = {
1542 &RISCV::FPR16RegClass, &RISCV::FPR32RegClass, &RISCV::FPR64RegClass};
1543 std::array<unsigned, 3> SubIdx = {RISCV::sub_16, RISCV::sub_32,
1546 for (
auto [RegClass, SubReg] :
zip(RegisterClasses, SubIdx)) {
1547 if (RegClass->contains(
Reg)) {
1549 TRI.getMatchingSuperReg(
Reg, SubReg, LargestFPRegClass))
1559void RISCVFrameLowering::emitZeroCallUsedRegs(
BitVector RegsToZero,
1568 DL =
MBBI->getDebugLoc();
1571 const RISCVRegisterInfo &
TRI = *
STI.getRegisterInfo();
1572 const RISCVInstrInfo &
TII = *
STI.getInstrInfo();
1574 BitVector FinalRegsToZero(
TRI.getNumRegs());
1576 bool HasVRegister =
false;
1579 if (
TRI.isGeneralPurposeRegister(MF,
Reg)) {
1581 }
else if (RISCV::GPRPairRegClass.
contains(
Reg)) {
1582 FinalRegsToZero.set(
1584 FinalRegsToZero.set(
1586 }
else if (
TRI.isFPRegister(
Reg)) {
1588 FinalRegsToZero.set(MaybeReg.id());
1590 TRI.getMinimalPhysRegClass(
Reg))) {
1591 if (!
STI.hasVInstructions())
1593 HasVRegister =
true;
1595 for (MCRegister SubReg :
TRI.subregs_inclusive(
Reg)) {
1596 if (
TRI.subregs(SubReg).empty())
1597 FinalRegsToZero.set(SubReg.id());
1605 VLMUL, 32,
true,
true);
1607 MCRegister TemporaryReg = RISCV::NoRegister;
1608 for (MCRegister
Reg : FinalRegsToZero.set_bits()) {
1609 if (
TRI.isGeneralPurposeRegister(MF,
Reg)) {
1615 if (TemporaryReg == RISCV::NoRegister) {
1616 RS->enterBasicBlockEnd(
MBB);
1617 TemporaryReg =
RS->scavengeRegisterBackwards(RISCV::GPRRegClass,
MBBI,
1626 FinalRegsToZero.set(TemporaryReg.
id());
1635 for (MCRegister
Reg : FinalRegsToZero.set_bits())
1650 STI.preferAscendingLoadStore());
1658 "Unexpected stack ID for the frame object.");
1670 MinCSFI = std::min(CSI.front().getFrameIdx(), CSI.back().getFrameIdx());
1671 MaxCSFI = std::max(CSI.front().getFrameIdx(), CSI.back().getFrameIdx());
1675 return FI == CS.getFrameIdx();
1678 bool IsInterruptCSR = RVFI->isSiFivePreemptibleInterrupt(MF) &&
1679 (FI == RVFI->getInterruptCSRFrameIndex(0) ||
1680 FI == RVFI->getInterruptCSRFrameIndex(1));
1683 if ((FI >= MinCSFI && FI <= MaxCSFI) || IsInterruptCSR ||
1684 IsInlineRestoredLibcallCSR) {
1687 if (FirstSPAdjustAmount)
1751 int64_t CLWSPMaxOffset = 252;
1752 int64_t CLDSPMaxOffset = 504;
1753 int64_t SPThreshold =
STI.is64Bit() ? CLDSPMaxOffset : CLWSPMaxOffset;
1754 if (SPOff >= 0 && SPOff <= SPThreshold)
1760 "Expected fixed object with stack realignment");
1761 assert(
hasFP(MF) &&
"Re-aligned stack must have frame pointer");
1765 if (FrameReg ==
FPReg) {
1784 "Can't index across variable sized realign");
1789 "Inconsistent stack layout");
1832 "Can't index across variable sized realign");
1834 RVFI->getRVVStackSize());
1841 int64_t ScalarLocalVarSize =
1843 RVFI->getVarArgsSaveSize() + RVFI->getRVVPadding();
1854 if (!BaseReg.isValid())
1874 for (
unsigned i = 0; CSRegs[i]; ++i) {
1875 unsigned CSReg = CSRegs[i];
1880 SavedRegs.
reset(CSReg);
1882 auto SubRegs =
TRI.subregs(CSReg);
1884 if (!
MRI.def_empty(CSReg) ||
MRI.getUsedPhysRegsMask().test(CSReg)) {
1885 SavedRegs.
set(CSReg);
1886 for (
unsigned Reg : SubRegs)
1904 if (RVFI->isSiFivePreemptibleInterrupt(MF))
1905 SavedRegs.
set(RISCV::X5);
1908 if (RVFI->isPushable(MF) && SavedRegs.
test(RISCV::X26))
1909 SavedRegs.
set(RISCV::X27);
1916 bool UseZilsd = !
STI.is64Bit() &&
STI.hasStdExtZilsd() &&
1918 !RVFI->isPushable(MF) && !RVFI->useSaveRestoreLibCalls(MF);
1922 for (
unsigned i = 0; CSRegs[i]; ++i) {
1924 CSRSet.
insert(CSRegs[i]);
1929 for (
MCPhysReg Pair : RISCV::GPRPairRegClass) {
1933 MCRegister EvenReg =
TRI.getSubReg(Pair, RISCV::sub_gpr_even);
1934 MCRegister OddReg =
TRI.getSubReg(Pair, RISCV::sub_gpr_odd);
1941 MRI.setCalleeSavedRegs(NewCSRs);
1942 CSRegs =
MRI.getCalleeSavedRegs();
1948 for (
unsigned i = 0; CSRegs[i]; ++i) {
1950 bool CombineToSuperReg;
1951 if (RISCV::GPRPairRegClass.
contains(CSReg)) {
1952 MCRegister EvenReg =
TRI.getSubReg(CSReg, RISCV::sub_gpr_even);
1953 MCRegister OddReg =
TRI.getSubReg(CSReg, RISCV::sub_gpr_odd);
1955 SavedRegs.
test(EvenReg.
id()) && SavedRegs.
test(OddReg.
id());
1958 if (
hasFP(MF) && CSReg == RISCV::X8_X9)
1959 CombineToSuperReg =
false;
1961 auto SubRegs =
TRI.subregs(CSReg);
1963 !SubRegs.empty() &&
llvm::all_of(SubRegs, [&](
unsigned Reg) {
1964 return SavedRegs.
test(Reg);
1968 if (CombineToSuperReg)
1969 SavedRegs.
set(CSReg);
1976std::pair<int64_t, Align>
1977RISCVFrameLowering::assignRVVStackObjectOffsets(
MachineFunction &MF)
const {
1981 auto pushRVVObjects = [&](
int FIBegin,
int FIEnd) {
1982 for (
int I = FIBegin, E = FIEnd;
I != E; ++
I) {
1995 if (!RVVCSI.empty())
1996 pushRVVObjects(RVVCSI[0].getFrameIdx(),
1997 RVVCSI[RVVCSI.size() - 1].getFrameIdx() + 1);
2001 Align RVVStackAlign(16);
2004 if (!
ST.hasVInstructions()) {
2006 "Can't allocate scalable-vector objects without V instructions");
2007 return std::make_pair(0, RVVStackAlign);
2012 for (
int FI : ObjectsToAllocate) {
2024 RVVStackAlign = std::max(RVVStackAlign, ObjectAlign);
2037 if (
auto RVVStackAlignVScale = RVVStackAlign.value() / VScale) {
2038 if (
auto AlignmentPadding =
2040 StackSize += AlignmentPadding;
2041 for (
int FI : ObjectsToAllocate)
2046 return std::make_pair(StackSize, RVVStackAlign);
2052 static constexpr unsigned ScavSlotsNumRVVSpillScalableObject = 2;
2056 static constexpr unsigned ScavSlotsNumRVVSpillNonScalableObject = 1;
2060 static constexpr unsigned ScavSlotsADDIScalableObject = 1;
2062 static constexpr unsigned MaxScavSlotsNumKnown =
2063 std::max({ScavSlotsADDIScalableObject, ScavSlotsNumRVVSpillScalableObject,
2064 ScavSlotsNumRVVSpillNonScalableObject});
2066 unsigned MaxScavSlotsNum = 0;
2072 for (
auto &MO :
MI.operands()) {
2078 MaxScavSlotsNum = std::max(
2079 MaxScavSlotsNum, IsScalableVectorID
2080 ? ScavSlotsNumRVVSpillScalableObject
2081 : ScavSlotsNumRVVSpillNonScalableObject);
2082 }
else if (
MI.getOpcode() == RISCV::ADDI && IsScalableVectorID) {
2084 std::max(MaxScavSlotsNum, ScavSlotsADDIScalableObject);
2087 if (MaxScavSlotsNum == MaxScavSlotsNumKnown)
2088 return MaxScavSlotsNumKnown;
2090 return MaxScavSlotsNum;
2114 unsigned FnSize = 0;
2115 for (
auto &
MBB : MF) {
2116 for (
auto &
MI :
MBB) {
2134 if (
MI.isConditionalBranch())
2135 FnSize +=
TII.getInstSizeInBytes(
MI);
2136 if (
MI.isConditionalBranch() ||
MI.isUnconditionalBranch()) {
2138 FnSize += 2 + 8 + 2 + 2;
2140 FnSize += 4 + 8 + 4 + 4;
2144 FnSize +=
TII.getInstSizeInBytes(
MI);
2159 int64_t RVVStackSize;
2160 Align RVVStackAlign;
2161 std::tie(RVVStackSize, RVVStackAlign) = assignRVVStackObjectOffsets(MF);
2163 RVFI->setRVVStackSize(RVVStackSize);
2164 RVFI->setRVVStackAlign(RVVStackAlign);
2173 unsigned ScavSlotsNum = 0;
2183 if (IsLargeFunction)
2184 ScavSlotsNum = std::max(ScavSlotsNum, 1u);
2191 for (
unsigned I = 0;
I < ScavSlotsNum;
I++) {
2193 RegInfo->getSpillAlign(*RC));
2194 RS->addScavengingFrameIndex(FI);
2196 if (IsLargeFunction && RVFI->getBranchRelaxationScratchFrameIndex() == -1)
2197 RVFI->setBranchRelaxationScratchFrameIndex(FI);
2200 unsigned Size = RVFI->getReservedSpillsSize();
2202 int FrameIdx = Info.getFrameIdx();
2208 RVFI->setCalleeSavedStackSize(
Size);
2232 int64_t Amount =
MI->getOperand(0).getImm();
2238 if (
MI->getOpcode() == RISCV::ADJCALLSTACKDOWN)
2244 if (
TLI->hasInlineStackProbe(MF) && -Amount >= ProbeSize) {
2248 bool DynAllocation =
2252 true, ProbeSize, DynAllocation,
2254 inlineStackProbe(MF,
MBB);
2263 return MBB.erase(
MI);
2281 const std::vector<CalleeSavedInfo> &CSI = MFI.getCalleeSavedInfo();
2287 if (RVFI->getReservedSpillsSize())
2292 if (!
isInt<12>(StackSize) && (CSI.size() > 0)) {
2305 if (
STI.hasStdExtZca()) {
2315 const uint64_t RVCompressLen =
STI.getXLen() * 8;
2322 auto CanCompress = [&](uint64_t CompressLen) ->
bool {
2323 if (StackSize <= 2047 + CompressLen ||
2324 (StackSize > 2048 * 2 - StackAlign &&
2325 StackSize <= 2047 * 2 + CompressLen) ||
2326 StackSize > 2048 * 3 - StackAlign)
2334 const uint64_t ADDI16SPCompressLen = 496;
2335 if (
STI.is64Bit() && CanCompress(ADDI16SPCompressLen))
2336 return ADDI16SPCompressLen;
2337 if (CanCompress(RVCompressLen))
2338 return RVCompressLen;
2340 return 2048 - StackAlign;
2347 std::vector<CalleeSavedInfo> &CSI)
const {
2354 if (RVFI->isSiFivePreemptibleInterrupt(MF)) {
2355 for (
int I = 0;
I < 2; ++
I) {
2356 int FI = RVFI->getInterruptCSRFrameIndex(
I);
2357 MFI.setIsCalleeSavedObjectIndex(FI,
true);
2365 if (RVFI->useQCIInterrupt(MF)) {
2369 if (RVFI->isPushable(MF)) {
2376 unsigned OnlyPushIfMoreThan = RVFI->useQCIInterrupt(MF) ? 2 : 0;
2377 if (PushedRegNum > OnlyPushIfMoreThan) {
2378 RVFI->setRVPushRegs(PushedRegNum);
2379 RVFI->setRVPushStackSize(
alignTo((
STI.getXLen() / 8) * PushedRegNum, 16));
2383 for (
auto &CS : CSI) {
2386 unsigned Size = RegInfo->getSpillSize(*RC);
2388 if (RVFI->useQCIInterrupt(MF)) {
2390 return P.first == CS.getReg();
2393 int64_t
Offset = FFI->second * (int64_t)
Size;
2395 int FrameIdx = MFI.CreateFixedSpillStackObject(
Size,
Offset);
2397 CS.setFrameIdx(FrameIdx);
2402 if (RVFI->useSaveRestoreLibCalls(MF) || RVFI->isPushable(MF)) {
2405 unsigned RegNum = std::distance(std::begin(
FixedCSRFIMap), FII);
2409 if (RVFI->getPushPopKind(MF) ==
2411 Offset = -int64_t(RVFI->getRVPushRegs() - RegNum) *
Size;
2415 if (RVFI->useQCIInterrupt(MF))
2418 int FrameIdx = MFI.CreateFixedSpillStackObject(
Size,
Offset);
2420 CS.setFrameIdx(FrameIdx);
2426 if (!
STI.is64Bit() &&
STI.hasStdExtZilsd() &&
2427 RISCV::GPRPairRegClass.contains(Reg)) {
2428 Align PairAlign =
STI.getZilsdAlign();
2429 int FrameIdx = MFI.CreateStackObject(8, PairAlign,
true);
2430 MFI.setIsCalleeSavedObjectIndex(FrameIdx,
true);
2431 CS.setFrameIdx(FrameIdx);
2436 Align Alignment = RegInfo->getSpillAlign(*RC);
2441 int FrameIdx = MFI.CreateStackObject(
Size, Alignment,
true);
2442 MFI.setIsCalleeSavedObjectIndex(FrameIdx,
true);
2443 CS.setFrameIdx(FrameIdx);
2448 if (RVFI->useQCIInterrupt(MF)) {
2451 MFI.CreateFixedSpillStackObject(
2455 if (RVFI->isPushable(MF)) {
2458 if (int64_t PushSize = RVFI->getRVPushStackSize())
2459 MFI.CreateFixedSpillStackObject(PushSize, -PushSize - QCIOffset);
2460 }
else if (
int LibCallRegs =
getLibCallID(MF, CSI) + 1) {
2479 unsigned LibCallFrameSize =
2481 RVFI->setLibCallStackSize(LibCallFrameSize);
2483 MFI.CreateFixedSpillStackObject(LibCallFrameSize,
2484 -
static_cast<int64_t
>(LibCallFrameSize));
2499 if (
MI !=
MBB.end() && !
MI->isDebugInstr())
2500 DL =
MI->getDebugLoc();
2509 ? RISCV::QC_C_MIENTER_NEST
2510 : RISCV::QC_C_MIENTER))
2520 if (PushedRegNum > 0) {
2528 PushBuilder.
addImm(RegEnc);
2531 for (
unsigned i = 0; i < PushedRegNum; i++)
2548 for (
auto &CS : CSI)
2553 const auto &UnmanagedCSI =
2558 for (
auto &CS : CSInfo) {
2562 TII.storeRegToStackSlot(
MBB,
MI, Reg, !
MBB.isLiveIn(Reg),
2567 storeRegsToStackSlots(UnmanagedCSI);
2568 storeRegsToStackSlots(RVVCSI);
2574 return RISCV::VRRegClass.contains(BaseReg) ? 1
2575 : RISCV::VRM2RegClass.contains(BaseReg) ? 2
2576 : RISCV::VRM4RegClass.contains(BaseReg) ? 4
2580void RISCVFrameLowering::emitCalleeSavedRVVPrologCFI(
2584 RISCVMachineFunctionInfo *RVFI = MF->
getInfo<RISCVMachineFunctionInfo>();
2585 const RISCVRegisterInfo &
TRI = *
STI.getRegisterInfo();
2596 FixedSize -= ScalarLocalVarSize;
2600 for (
auto &CS : RVVCSI) {
2602 int FI = CS.getFrameIdx();
2605 for (
unsigned i = 0; i < NumRegs; ++i) {
2613void RISCVFrameLowering::emitCalleeSavedRVVEpilogCFI(
2617 const RISCVRegisterInfo &
TRI = *
STI.getRegisterInfo();
2621 for (
auto &CS : RVVCSI) {
2624 for (
unsigned i = 0; i < NumRegs; ++i)
2625 CFIHelper.buildRestore(BaseReg + i);
2638 if (
MI !=
MBB.end() && !
MI->isDebugInstr())
2639 DL =
MI->getDebugLoc();
2647 const auto &UnmanagedCSI =
2652 for (
auto &CS : CSInfo) {
2656 RISCV::NoSubRegister,
2659 "loadRegFromStackSlot didn't insert any code!");
2662 loadRegFromStackSlot(RVVCSI);
2663 loadRegFromStackSlot(UnmanagedCSI);
2669 assert(
MI->getOpcode() == RISCV::QC_C_MILEAVERET &&
2670 "Unexpected QCI Interrupt Return Instruction");
2675 if (PushedRegNum > 0) {
2682 PopBuilder.
addImm(RegEnc);
2690 "Expected restore with libcall to use save restore libcalls");
2711 for (
auto &CS : CSI)
2716 if (
MI !=
MBB.end() &&
MI->getOpcode() == RISCV::PseudoRET) {
2718 MI->eraseFromParent();
2750 if (
STI.preferVsetvliOverReadVLENB() &&
2751 (
MBB.isLiveIn(RISCV::VTYPE) ||
MBB.isLiveIn(RISCV::VL)))
2762 RS.enterBasicBlock(*TmpMBB);
2763 return !RS.isRegUsed(RISCV::X5);
2782 if (
MBB.succ_size() > 1)
2799 return !MI.isDebugInstr();
2815 assert(TargetReg != RISCV::X2 &&
"New top of stack cannot already be in SP");
2816 assert(ScratchReg != RISCV::X2 &&
"Scratch register cannot be SP");
2817 assert(TargetReg != ScratchReg &&
"Target and scratch must be different");
2825 Align StackAlign =
Subtarget.getFrameLowering()->getStackAlign();
2827 uint64_t ProbeSize =
TLI->getStackProbeSize(MF, StackAlign);
2832 MF.
insert(MBBInsertPoint, LoopTestMBB);
2834 MF.
insert(MBBInsertPoint, ExitMBB);
2838 TII->movImm(
MBB,
MBBI,
DL, ScratchReg, ProbeSize, Flags);
2849 TII->get(IsRV64 ? RISCV::SD : RISCV::SW))
2884 MBB.addSuccessor(LoopTestMBB);
2894 SmallVector<MachineInstr *, 4> ToReplace;
2895 for (MachineInstr &
MI :
MBB) {
2896 unsigned Opc =
MI.getOpcode();
2897 if (
Opc == RISCV::PROBED_STACKALLOC ||
2898 Opc == RISCV::PROBED_STACKALLOC_RVV) {
2903 for (MachineInstr *
MI : ToReplace) {
2904 if (
MI->getOpcode() == RISCV::PROBED_STACKALLOC ||
2905 MI->getOpcode() == RISCV::PROBED_STACKALLOC_RVV) {
2908 Register TargetReg =
MI->getOperand(0).getReg();
2914 "No available scratch register for stack probe loop");
2917 (
MI->getOpcode() == RISCV::PROBED_STACKALLOC_RVV));
static void getLiveRegsForEntryMBB(LivePhysRegs &LiveRegs, const MachineBasicBlock &MBB)
const AArch64Subtarget & Subtarget
const TargetLowering & TLI
static MCCFIInstruction createDefCFAExpression(const TargetRegisterInfo &TRI, unsigned Reg, const StackOffset &Offset)
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
const AArch64InstrInfo & TII
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file contains constants used for implementing Dwarf debug support.
static void emitSCSPrologue(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL)
static void emitSCSEpilogue(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL)
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
static uint64_t estimateFunctionSizeInBytes(const LoongArchInstrInfo *TII, const MachineFunction &MF)
static void emitStackProbeInline(MachineBasicBlock::iterator MBBI, DebugLoc DL, Register TargetReg)
Register const TargetRegisterInfo * TRI
Promote Memory to Register
static constexpr uint64_t QCIInterruptPushAmount
static void emitSiFiveCLICStackSwap(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL, MachineInstr::MIFlag FrameFlag)
static unsigned getPushOpcode(RISCVMachineFunctionInfo::PushPopKind Kind, bool UpdateFP)
static void emitSiFiveCLICPreemptibleSaves(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, const DebugLoc &DL)
static MCRegister getRVVBaseRegister(const RISCVRegisterInfo &TRI, const Register &Reg)
static void createSiFivePreemptibleInterruptFrameEntries(MachineFunction &MF, RISCVMachineFunctionInfo &RVFI)
static constexpr MCPhysReg FPReg
static const char * getRestoreLibCallName(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static bool needsDwarfCFI(const MachineFunction &MF)
Returns true if DWARF CFI instructions ("frame moves") should be emitted.
static constexpr MCPhysReg SPReg
static const char * getSpillLibCallName(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static bool hasRVVFrameObject(const MachineFunction &MF)
static SmallVector< CalleeSavedInfo, 8 > getUnmanagedInterruptCSI(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI, bool ReverseOrder=false)
static void appendScalableVectorExpression(const TargetRegisterInfo &TRI, SmallVectorImpl< char > &Expr, StackOffset Offset, llvm::raw_string_ostream &Comment)
static SmallVector< CalleeSavedInfo, 8 > getQCISavedInfo(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static SmallVector< CalleeSavedInfo, 8 > getRVVCalleeSavedInfo(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static SmallVector< CalleeSavedInfo, 8 > getUnmanagedCSI(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI, bool ReverseOrder=false)
static void emitSiFiveCLICPreemptibleRestores(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, CFIInstBuilder &CFIBuilder, const DebugLoc &DL)
static bool isPop(unsigned Opcode)
static unsigned getCalleeSavedRVVNumRegs(const Register &BaseReg)
static MCCFIInstruction createDefCFAOffset(const TargetRegisterInfo &TRI, Register Reg, StackOffset Offset)
static unsigned getPopOpcode(RISCVMachineFunctionInfo::PushPopKind Kind)
static SmallVector< CalleeSavedInfo, 8 > getPushOrLibCallsSavedInfo(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static int getLibCallID(const MachineFunction &MF, const std::vector< CalleeSavedInfo > &CSI)
static const std::pair< MCPhysReg, int8_t > FixedCSRFIQCIInterruptMap[]
static bool isPush(unsigned Opcode)
static constexpr MCPhysReg RAReg
static MCRegister getLargestFPRegisterOrZero(const RISCVSubtarget &STI, const TargetRegisterInfo &TRI, MCRegister Reg)
static const MCPhysReg FixedCSRFIMap[]
static int getSiFiveCLICScratchFrameIndex(const MachineFunction &MF)
static unsigned getNumPushPopRegs(const std::vector< CalleeSavedInfo > &CSI)
static MCRegister getPhysicalGPR(const TargetRegisterInfo &TRI, MCRegister Reg)
static unsigned getScavSlotsNumForRVV(MachineFunction &MF)
MachineRegisterInfo & MRI
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),...
bool empty() const
Check if the array is empty.
LLVM_ABI StringRef getValueAsString() const
Return the attribute's value as a string.
bool test(unsigned Idx) const
Returns true if bit Idx is set.
BitVector & reset()
Reset all bits in the bitvector.
BitVector & set()
Set all bits in the bitvector.
iterator_range< const_set_bits_iterator > set_bits() const
Helper class for creating CFI instructions and inserting them into MIR.
void buildEscape(StringRef Bytes, StringRef Comment="") const
void buildDefCFAOffset(int64_t Offset, MCSymbol *Label=nullptr) const
void buildRestore(MCRegister Reg) const
void buildDefCFARegister(MCRegister Reg) const
void buildOffset(MCRegister Reg, int64_t Offset) const
void insertCFIInst(const MCCFIInstruction &CFIInst) const
void buildDefCFA(MCRegister Reg, int64_t Offset) const
void setInsertPoint(MachineBasicBlock::iterator IP)
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
MCRegister getReg() const
Diagnostic information for unsupported feature in backend.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
bool hasOptNone() const
Do not optimize this function (-O0).
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
LLVM_ABI void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
A set of physical registers with utility functions to track liveness when walking backward/forward th...
static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals, SMLoc Loc={}, StringRef Comment="")
.cfi_escape Allows the user to add arbitrary bytes to the unwind info.
bool contains(MCRegister Reg) const
contains - Return true if the specified register is included in this register class.
Wrapper class representing physical registers. Should be passed by value.
constexpr unsigned id() const
LLVM_ABI void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
LLVM_ABI MachineBasicBlock * getFallThrough(bool JumpToFallThrough=true)
Return the fallthrough block if the block can implicitly transfer control to the block after it by fa...
LLVM_ABI iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
bool isReturnBlock() const
Convenience function that returns true if the block ends in a return instruction.
LLVM_ABI void addSuccessor(MachineBasicBlock *Succ, BranchProbability Prob=BranchProbability::getUnknown())
Add Succ as a successor of this MachineBasicBlock.
LLVM_ABI DebugLoc findDebugLoc(instr_iterator MBBI)
Find the next valid DebugLoc starting at MBBI, skipping any debug instructions.
LLVM_ABI void eraseFromParent()
This method unlinks 'this' from the containing function and deletes it.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
void splice(iterator Where, MachineBasicBlock *Other, iterator From)
Take an instruction from MBB 'Other' at the position From, and insert it into this MBB right before '...
MachineInstrBundleIterator< MachineInstr > iterator
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
bool adjustsStack() const
Return true if this function adjusts the stack – e.g., when calling another function.
LLVM_ABI int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)
Create a new statically sized stack object, returning a nonnegative identifier to represent it.
LLVM_ABI void ensureMaxAlignment(Align Alignment)
Make sure the function's frame is at least Align bytes aligned.
bool isFrameAddressTaken() const
This method may be called any time after instruction selection is complete to determine if there is a...
Align getMaxAlign() const
Return alignment of this function's frame.
void setObjectOffset(int ObjectIdx, int64_t SPOffset)
Set the stack frame offset of the specified object.
uint64_t getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call.
int64_t getOffsetAdjustment() const
Return the correction for frame offsets.
LLVM_ABI uint64_t estimateStackSize(const MachineFunction &MF) const
Estimate and return the size of the stack frame.
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.
bool isMaxCallFrameSizeComputed() const
LLVM_ABI int CreateSpillStackObject(uint64_t Size, Align Alignment, TargetStackID::Value StackID=TargetStackID::Default)
Create a new statically sized stack object that represents a spill slot, returning a nonnegative iden...
const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const
Returns a reference to call saved info vector for the current function.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
uint8_t getStackID(int ObjectIdx) const
int64_t getObjectOffset(int ObjectIdx) const
Return the assigned stack offset of the specified object from the incoming stack pointer.
void setStackSize(uint64_t Size)
Set the size of the stack.
bool isFixedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a fixed stack object.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
bool needsFrameMoves() const
True if this function needs frame moves for debug or exceptions.
MachineFrameInfo & getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
BasicBlockListType::iterator iterator
bool disableFramePointerElim() const
Returns true if frame pointer elimination should be disabled for this function.
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
const MachineBasicBlock & front() const
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineInstr - Allocate a new MachineInstr.
void insert(iterator MBBI, MachineBasicBlock *MBB)
const MachineInstrBuilder & addExternalSymbol(const char *FnName, unsigned TargetFlags=0) const
const MachineInstrBuilder & addUse(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a virtual register use operand.
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 & addMBB(MachineBasicBlock *MBB, unsigned TargetFlags=0) const
const MachineInstrBuilder & addDef(Register RegNo, RegState Flags={}, unsigned SubReg=0) const
Add a virtual register definition operand.
const MachineInstrBuilder & setMIFlags(unsigned Flags) const
MachineInstr * getInstr() const
If conversion operators fail, use this method to get the MachineInstr explicitly.
Representation of each machine instruction.
LLVM_ABI void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI)
Copy implicit register operands from specified instruction to this instruction.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
bool isReserved(MCRegister PhysReg) const
isReserved - Returns true when PhysReg is a reserved register.
LLVM_ABI Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
LLVM_ABI const MCPhysReg * getCalleeSavedRegs() const
Returns list of callee saved registers.
Represent a mutable reference to an array (0 or more elements consecutively in memory),...
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const override
assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.
uint64_t getFirstSPAdjustAmount(const MachineFunction &MF) const
bool enableShrinkWrapping(const MachineFunction &MF) const override
Returns true if the target will correctly handle shrink wrapping.
uint64_t getStackThreshold() const override
getStackThreshold - Return the maximum stack size
bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...
bool hasBP(const MachineFunction &MF) const
void allocateStack(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, MachineFunction &MF, uint64_t Offset, uint64_t RealStackSize, bool EmitCFI, bool NeedProbe, uint64_t ProbeSize, bool DynAllocation, MachineInstr::MIFlag Flag) const
bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a epilogue for the target.
bool hasFPImpl(const MachineFunction &MF) const override
Register findScratchNonCalleeSaveRegister(MachineBasicBlock *MBB, Register PreferredReg, Register DontUseReg=Register()) const
bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const override
restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...
bool hasReservedCallFrame(const MachineFunction &MF) const override
hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...
Register getInitialCFARegister(const MachineFunction &MF) const override
Return initial CFA register value i.e.
const RISCVSubtarget & STI
StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const override
getFrameIndexReference - This method should return the base register and offset used to reference a f...
bool isSupportedStackID(TargetStackID::Value ID) const override
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override
TargetStackID::Value getStackIDForScalableVectors() const override
Returns the StackID that scalable vectors should be associated with.
int getInitialCFAOffset(const MachineFunction &MF) const override
Return initial CFA offset value i.e.
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
bool canUseAsPrologue(const MachineBasicBlock &MBB) const override
Check whether or not the given MBB can be used as a prologue for the target.
RISCVFrameLowering(const RISCVSubtarget &STI)
uint64_t getStackSizeWithRVVPadding(const MachineFunction &MF) const
RISCVMachineFunctionInfo - This class is derived from MachineFunctionInfo and contains private RISCV-...
bool isPushable(const MachineFunction &MF) const
InterruptStackKind getInterruptStackKind(const MachineFunction &MF) const
bool useSiFiveInterrupt(const MachineFunction &MF) const
bool isSiFivePreemptibleInterrupt(const MachineFunction &MF) const
void pushInterruptCSRFrameIndex(int FI)
PushPopKind getPushPopKind(const MachineFunction &MF) const
bool hasShadowStack(const MachineFunction &MF) const
uint64_t getRVVPadding() const
unsigned getRVPushRegs() const
bool useSaveRestoreLibCalls(const MachineFunction &MF) const
unsigned getVarArgsSaveSize() const
bool useQCIInterrupt(const MachineFunction &MF) const
unsigned getCalleeSavedStackSize() const
bool hasCFProtectionBranch() const
TargetRegisterClass const * getLargestFPRegClass() const
bool hasVInstructions() const
const RISCVRegisterInfo * getRegisterInfo() const override
const RISCVInstrInfo * getInstrInfo() const override
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
Represents a location in source code.
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
bool contains(const T &V) const
Check if the SmallSet contains the given element.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...
void append(StringRef RHS)
Append from a StringRef.
StringRef str() const
Explicit conversion to StringRef.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StackOffset holds a fixed and a scalable offset in bytes.
int64_t getFixed() const
Returns the fixed component of the stack.
int64_t getScalable() const
Returns the scalable component of the stack.
static StackOffset get(int64_t Fixed, int64_t Scalable)
static StackOffset getScalable(int64_t Scalable)
static StackOffset getFixed(int64_t Fixed)
Represent a constant reference to a string, i.e.
unsigned getStackAlignment() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
bool hasFP(const MachineFunction &MF) const
hasFP - Return true if the specified function should have a dedicated frame pointer register.
virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
int getOffsetOfLocalArea() const
getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...
TargetFrameLowering(StackDirection D, Align StackAl, int LAO, Align TransAl=Align(1), bool StackReal=true)
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
int alignSPAdjust(int SPAdj) const
alignSPAdjust - This method aligns the stack adjustment to the correct alignment.
TargetInstrInfo - Interface to description of machine instruction set.
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
bool hasStackRealignment(const MachineFunction &MF) const
True if stack realignment is required and still possible.
virtual const TargetInstrInfo * getInstrInfo() const
virtual const TargetRegisterInfo * getRegisterInfo() const =0
Return the target's register information.
self_iterator getIterator()
A raw_ostream that writes to an std::string.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
@ GHC
Used by the Glasgow Haskell Compiler (GHC).
static VLMUL encodeLMUL(unsigned LMUL, bool Fractional)
LLVM_ABI unsigned encodeVTYPE(VLMUL VLMUL, unsigned SEW, bool TailAgnostic, bool MaskAgnostic, bool AltFmt=false)
static unsigned encodeRegListNumRegs(unsigned NumRegs)
static constexpr unsigned RVVBitsPerBlock
bool isRVVSpill(const MachineInstr &MI)
static constexpr unsigned RVVBytesPerBlock
BaseReg
Stack frame base register. Bit 0 of FREInfo.Info.
This is an optimization pass for GlobalISel generic memory operations.
IterT next_nodbg(IterT It, IterT End, bool SkipPseudoOp=true)
Increment It, then continue incrementing it while it points to a debug instruction.
detail::zippy< detail::zip_shortest, T, U, Args... > zip(T &&t, U &&u, Args &&...args)
zip iterator for two or more iteratable types.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
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.
@ Implicit
Not emitted register (e.g. carry, or temporary result).
@ Kill
The last use of a register.
constexpr T alignDown(U Value, V Align, W Skew=0)
Returns the largest unsigned integer less than or equal to Value and is Skew mod Align.
LLVM_ABI void reportFatalInternalError(Error Err)
Report a fatal error that indicates a bug in LLVM.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
auto make_first_range(ContainerTy &&c)
Given a container of pairs, return a range over the first elements.
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
uint64_t offsetToAlignment(uint64_t Value, Align Alignment)
Returns the offset to the next integer (mod 2**64) that is greater than or equal to Value and is a mu...
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
auto count_if(R &&Range, UnaryPredicate P)
Wrapper function around std::count_if to count the number of times an element satisfying a given pred...
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
void appendLEB128(SmallVectorImpl< U > &Buffer, T Value)
unsigned Log2(Align A)
Returns the log2 of the alignment.
void fullyRecomputeLiveIns(ArrayRef< MachineBasicBlock * > MBBs)
Convenience function for recomputing live-in's for a set of MBBs until the computation converges.
LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)
Prints virtual and physical registers with or without a TRI instance.
MCRegisterClass TargetRegisterClass
This struct is a compact representation of a valid (non-zero power of two) alignment.
constexpr uint64_t value() const
This is a hole in the type system and should not be abused.
static bool isRVVRegClass(const TargetRegisterClass *RC)
void adjustReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator II, const DebugLoc &DL, Register DestReg, Register SrcReg, StackOffset Offset, MachineInstr::MIFlag Flag, MaybeAlign RequiredAlign) const