70#define DEBUG_TYPE "hexagon-pei"
80 return containsHLXObject(HST, EltTy);
178 if (!HST.getFrameLowering()->hasFP(MF))
189 Register SCSPReg = HST.getSCSPReg();
190 const auto &HRI = *HST.getRegisterInfo();
191 if (!HST.isRegisterReservedByUser(SCSPReg))
196 " to use shadow call stack on Hexagon");
198 const auto &HII = *HST.getInstrInfo();
212 MBB.addLiveIn(SCSPReg);
219 unsigned DwarfSCSReg = HRI.getDwarfRegNum(SCSPReg,
true);
222 assert(DwarfSCSReg < 32 &&
"SCS register should be < 32");
223 const char CFIInst[] = {
224 (
char)dwarf::DW_CFA_val_expression,
227 (
char)(
unsigned)(dwarf::DW_OP_breg0 + DwarfSCSReg),
247 Register SCSPReg = HST.getSCSPReg();
248 const auto &HII = *HST.getInstrInfo();
251 BuildMI(
MBB,
MI,
DL, HII.get(Hexagon::L2_loadri_io), Hexagon::R31)
270 cl::desc(
"Set the number of scavenger slots"),
275 cl::desc(
"Specify O2(not Os) spill func threshold"),
280 cl::desc(
"Specify Os spill func threshold"),
289 cl::desc(
"Enable stack frame shrink wrapping"));
294 cl::desc(
"Max count of stack frame shrink-wraps"));
298 cl::desc(
"Enable long calls for save-restore stubs."),
303 cl::init(std::numeric_limits<unsigned>::max()),
304 cl::desc(
"Maximum HLX vector (VTCM) stack frame size in bytes"));
314 cl::desc(
"Save the caller's VSP on the stack in functions with an HLX "
315 "vector stack frame, for debuggers"));
319 cl::init(std::numeric_limits<unsigned>::max()));
338 char HexagonCallFrameInformation::ID = 0;
342bool HexagonCallFrameInformation::runOnMachineFunction(
MachineFunction &MF) {
343 auto &HFI = *MF.
getSubtarget<HexagonSubtarget>().getFrameLowering();
348 HFI.insertCFIInstructions(MF);
353 "Hexagon call frame information",
false,
false)
356 return new HexagonCallFrameInformation();
373 if (!RegNo || SubReg < RegNo)
383 static_assert(Hexagon::R1 > 0,
384 "Assume physical registers are encoded as positive integers");
389 for (
unsigned I = 1,
E = CSI.
size();
I <
E; ++
I) {
410 unsigned Opc =
MI.getOpcode();
412 case Hexagon::PS_alloca:
435 for (
MCPhysReg S : HRI.subregs_inclusive(R))
440 if (MO.isRegMask()) {
445 const uint32_t *BM = MO.getRegMask();
449 if (!(BM[R / 32] & (1u << (R % 32))))
464 unsigned RetOpc =
I->getOpcode();
465 return RetOpc == Hexagon::PS_tailcall_i || RetOpc == Hexagon::PS_tailcall_r;
487 case Hexagon::RESTORE_DEALLOC_RET_JMP_V4:
488 case Hexagon::RESTORE_DEALLOC_RET_JMP_V4_PIC:
489 case Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT:
490 case Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT_PIC:
491 case Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT:
492 case Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT_PIC:
493 case Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4:
494 case Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_PIC:
507 return F.hasOptSize() && !
F.hasMinSize();
519 MachineBasicBlock *&PrologB, MachineBasicBlock *&EpilogB)
const {
520 static unsigned ShrinkCounter = 0;
522 if (MF.
getSubtarget<HexagonSubtarget>().isEnvironmentMusl() &&
535 auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
537 MachineDominatorTree MDT;
539 MachinePostDominatorTree MPT;
542 using UnsignedMap = DenseMap<unsigned, unsigned>;
543 using RPOTType = ReversePostOrderTraversal<const MachineFunction *>;
549 RPO[
I->getNumber()] = RPON++;
555 unsigned BN = RPO[
I.getNumber()];
556 for (MachineBasicBlock *Succ :
I.successors())
558 if (RPO[Succ->getNumber()] <= BN)
565 BitVector CSR(Hexagon::NUM_TARGET_REGS);
566 for (
const MCPhysReg *
P = HRI.getCalleeSavedRegs(&MF); *
P; ++
P)
575 dbgs() <<
"Blocks needing SF: {";
576 for (
auto &
B : SFBlocks)
581 if (SFBlocks.
empty())
585 MachineBasicBlock *DomB = SFBlocks[0];
586 for (
unsigned i = 1, n = SFBlocks.
size(); i < n; ++i) {
591 MachineBasicBlock *PDomB = SFBlocks[0];
592 for (
unsigned i = 1, n = SFBlocks.
size(); i < n; ++i) {
598 dbgs() <<
"Computed dom block: ";
603 dbgs() <<
", computed pdom block: ";
619 LLVM_DEBUG(
dbgs() <<
"PDom block does not post-dominate dom block\n");
642 findShrunkPrologEpilog(MF, PrologB, EpilogB);
644 bool PrologueStubs =
false;
646 insertCSRSpillsInBlock(*PrologB, CSI, HRI, PrologueStubs);
652 insertAlignaInBlock(*PrologB, AfterCSR);
653 insertPrologueInBlock(*PrologB, PrologueStubs);
661 while (AfterProlog != PrologB->
end() &&
667 updateEntryPaths(MF, *PrologB);
670 insertCSRRestoresInBlock(*EpilogB, CSI, HRI);
671 insertEpilogueInBlock(*EpilogB);
674 if (
B.isReturnBlock())
675 insertCSRRestoresInBlock(
B, CSI, HRI);
678 if (
B.isReturnBlock())
679 insertEpilogueInBlock(
B);
697 BitVector DoneT(MaxBN+1), DoneF(MaxBN+1), Path(MaxBN+1);
698 updateExitPaths(*EpilogB, *EpilogB, DoneT, DoneF, Path);
707 assert(
F.hasFnAttribute(Attribute::NoReturn) &&
708 F.getFunction().hasFnAttribute(Attribute::NoUnwind) &&
709 !
F.getFunction().hasFnAttribute(Attribute::UWTable));
725 assert(!MFI.hasVarSizedObjects() &&
726 !HST.getRegisterInfo()->hasStackRealignment(MF));
727 return F.hasFnAttribute(Attribute::NoReturn) &&
728 F.hasFnAttribute(Attribute::NoUnwind) &&
729 !
F.hasFnAttribute(Attribute::UWTable) && HST.noreturnStackElim() &&
730 MFI.getStackSize() == 0;
733void HexagonFrameLowering::insertPrologueInBlock(MachineBasicBlock &
MBB,
734 bool PrologueStubs)
const {
740 auto &HMFI = *MF.
getInfo<HexagonMachineFunctionInfo>();
743 uint64_t VTCMFrameSize = HMFI.getVTCMFrameInfo().getStackSize();
752 FrameSize = MaxCFA +
alignTo(FrameSize, MaxAlign);
763 SmallVector<MachineInstr *, 4> AdjustRegs;
766 if (
MI.getOpcode() == Hexagon::PS_alloca)
769 for (
auto *
MI : AdjustRegs) {
770 assert((
MI->getOpcode() == Hexagon::PS_alloca) &&
"Expected alloca");
771 expandAlloca(
MI, MF, HII, SP, MaxCF);
772 MI->eraseFromParent();
777 if (MF.getFunction().isVarArg() &&
778 MF.getSubtarget<HexagonSubtarget>().isEnvironmentMusl()) {
780 int NumVarArgRegs = 6 - FirstVarArgSavedReg;
781 int RegisterSavedAreaSizePlusPadding = (NumVarArgRegs % 2 == 0)
783 : NumVarArgRegs * 4 + 4;
784 if (RegisterSavedAreaSizePlusPadding > 0) {
787 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
789 .
addImm(-RegisterSavedAreaSizePlusPadding)
794 auto &HMFI = *MF.getInfo<HexagonMachineFunctionInfo>();
795 for (
int i = HMFI.getFirstNamedArgFrameIndex(),
796 e = HMFI.getLastNamedArgFrameIndex(); i >= e; --i) {
804 unsigned LDOpc, STOpc;
808 if (ObjAlign > ObjSize) {
811 else if (ObjSize <= 2)
813 else if (ObjSize <= 4)
815 else if (ObjSize > 4)
819 switch (OpcodeChecker) {
821 LDOpc = Hexagon::L2_loadrb_io;
822 STOpc = Hexagon::S2_storerb_io;
825 LDOpc = Hexagon::L2_loadrh_io;
826 STOpc = Hexagon::S2_storerh_io;
829 LDOpc = Hexagon::L2_loadri_io;
830 STOpc = Hexagon::S2_storeri_io;
834 LDOpc = Hexagon::L2_loadrd_io;
835 STOpc = Hexagon::S2_storerd_io;
839 Register RegUsed = LDOpc == Hexagon::L2_loadrd_io ? Hexagon::D3
841 int LoadStoreCount = ObjSize / OpcodeChecker;
843 if (ObjSize % OpcodeChecker)
851 NumBytes =
alignTo(NumBytes, ObjAlign);
854 while (
Count < LoadStoreCount) {
856 BuildMI(
MBB, InsertPt, dl, HII.get(LDOpc), RegUsed)
858 .
addImm(RegisterSavedAreaSizePlusPadding +
875 NumBytes =
alignTo(NumBytes, 8);
880 NumBytes = (NumVarArgRegs % 2 == 0) ? NumBytes : NumBytes + 4;
882 for (
int j = FirstVarArgSavedReg, i = 0;
j < 6; ++
j, ++i) {
883 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::S2_storeri_io))
893 insertAllocframe(
MBB, InsertPt, NumBytes);
895 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_andir), SP)
897 .
addImm(-int64_t(MaxAlign.value()));
903 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::PS_call_stk))
905 }
else if (NumBytes > 0) {
907 auto *
TLI = HST.getTargetLowering();
909 unsigned ProbeSize = 0;
912 ProbeSize =
TLI->getStackProbeSize(MF, StackAlign);
914 if (NeedsProbing && NumBytes > ProbeSize) {
916 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), Hexagon::R28)
921 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::PS_probed_stackalloc))
925 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
933 if (
int VSPFI = HMFI.getVSPFrameIndex(); VSPFI >= 0) {
937 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_tfrcrr), Hexagon::R7)
940 HII.storeRegToStackSlot(
MBB, InsertPt, Hexagon::R7,
true, VSPFI,
941 &Hexagon::IntRegsRegClass,
Register());
944 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::V2_vallocframe_imm))
945 .
addImm(VTCMFrameSize / 2048)
949void HexagonFrameLowering::insertEpilogueInBlock(MachineBasicBlock &
MBB)
const {
959 const auto &HMFI = *MF.
getInfo<HexagonMachineFunctionInfo>();
960 uint64_t VTCMFrameSize = HMFI.getVTCMFrameInfo().getStackSize();
962 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::V2_vdeallocframe_imm))
963 .
addImm(VTCMFrameSize / 2048);
969 MF.
getSubtarget<HexagonSubtarget>().isEnvironmentMusl()) {
971 int NumVarArgRegs = 6 - FirstVarArgSavedReg;
972 int RegisterSavedAreaSizePlusPadding = (NumVarArgRegs % 2 == 0) ?
973 (NumVarArgRegs * 4) : (NumVarArgRegs * 4 + 4);
974 NumBytes += RegisterSavedAreaSizePlusPadding;
977 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
985 unsigned RetOpc = RetI ? RetI->
getOpcode() : 0;
988 if (RetOpc == Hexagon::EH_RETURN_JMPR) {
991 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::L2_deallocframe))
994 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_add), SP)
1005 if (RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4 ||
1006 RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4_PIC ||
1007 RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT ||
1008 RetOpc == Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT_PIC) {
1012 while (It !=
MBB.
end()) {
1025 bool NeedsDeallocframe =
true;
1026 unsigned PrevOpc = 0;
1029 PrevOpc = PrevIt->getOpcode();
1030 if (PrevOpc == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4 ||
1031 PrevOpc == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_PIC ||
1032 PrevOpc == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT ||
1033 PrevOpc == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT_PIC ||
1034 PrevOpc == Hexagon::PS_call_nr || PrevOpc == Hexagon::PS_callr_nr)
1035 NeedsDeallocframe =
false;
1038 if (!MF.
getSubtarget<HexagonSubtarget>().isEnvironmentMusl() ||
1040 if (!NeedsDeallocframe) {
1045 if (NeedsSCS && PrevOpc != Hexagon::PS_call_nr &&
1046 PrevOpc != Hexagon::PS_callr_nr)
1048 "useRestoreFunction() should have prevented this");
1055 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::L2_deallocframe))
1064 unsigned NewOpc = Hexagon::L4_return;
1065 MachineInstrBuilder NewI =
BuildMI(
MBB, RetI, dl, HII.get(NewOpc))
1075 int NumVarArgRegs = 6 - FirstVarArgSavedReg;
1076 int RegisterSavedAreaSizePlusPadding = (NumVarArgRegs % 2 == 0) ?
1077 (NumVarArgRegs * 4) : (NumVarArgRegs * 4 + 4);
1082 bool HasRestoreStub =
1084 (
I->getOpcode() == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT ||
1086 Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT_PIC ||
1087 I->getOpcode() == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4 ||
1088 I->getOpcode() == Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_PIC);
1089 if (!HasRestoreStub)
1090 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::L2_deallocframe))
1093 if (RegisterSavedAreaSizePlusPadding != 0)
1094 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
1096 .
addImm(RegisterSavedAreaSizePlusPadding);
1100 if (NeedsSCS && !HasRestoreStub)
1105void HexagonFrameLowering::insertAllocframe(MachineBasicBlock &
MBB,
1114 const unsigned int ALLOCFRAME_MAX = 16384;
1124 auto *
TLI = HST.getTargetLowering();
1126 unsigned ProbeSize = 0;
1129 ProbeSize =
TLI->getStackProbeSize(MF, StackAlign);
1132 if (NeedsProbing && NumBytes > ProbeSize) {
1134 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::S2_allocframe))
1142 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), Hexagon::R28)
1148 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::PS_probed_stackalloc))
1151 }
else if (NumBytes >= ALLOCFRAME_MAX) {
1153 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::S2_allocframe))
1162 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::A2_addi), SP)
1167 BuildMI(
MBB, InsertPt, dl, HII.get(Hexagon::S2_allocframe))
1182 if (
MI.getOpcode() == Hexagon::PS_probed_stackalloc)
1187 auto *
TLI = HST.getTargetLowering();
1189 unsigned ProbeSize =
TLI->getStackProbeSize(MF, StackAlign);
1195 Register TargetReg =
MI->getOperand(0).getReg();
1202 MF.
insert(InsertPt, LoopMBB);
1205 MF.
insert(InsertPt, ExitMBB);
1226 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::A2_addi),
1232 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::S4_storeiri_io))
1238 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::C2_cmpgtu),
1244 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::J2_jumpt))
1250 BuildMI(*ExitMBB, ExitMBB->
begin(),
DL, HII.get(Hexagon::A2_tfr),
1256 MBB->addSuccessor(LoopMBB);
1261 MI->eraseFromParent();
1268void HexagonFrameLowering::insertAlignaInBlock(
1276 assert(needsAligna(MF) &&
"Unexpected stack align base register");
1281 BuildMI(
MBB, InsertPt,
DL, HII.get(Hexagon::PS_aligna), AP)
1295 for (
unsigned i = 0; i < Worklist.
size(); ++i) {
1296 unsigned BN = Worklist[i];
1299 if (!
MBB.isLiveIn(R.getReg()))
1300 MBB.addLiveIn(R.getReg());
1302 for (
auto &SB :
MBB.successors())
1303 Worklist.
insert(SB->getNumber());
1307bool HexagonFrameLowering::updateExitPaths(MachineBasicBlock &
MBB,
1308 MachineBasicBlock &RestoreB, BitVector &DoneT, BitVector &DoneF,
1309 BitVector &Path)
const {
1312 if (Path[BN] || DoneF[BN])
1320 bool ReachedExit =
false;
1322 ReachedExit |= updateExitPaths(*SB, RestoreB, DoneT, DoneF, Path);
1328 MachineInstr &RetI =
MBB.
back();
1338 if (ReachedExit && &
MBB != &RestoreB) {
1351static std::optional<MachineBasicBlock::iterator>
1358 auto End =
B.instr_end();
1362 if (!
I.isBundle()) {
1363 if (
I.getOpcode() == Hexagon::S2_allocframe)
1364 return std::next(It);
1368 bool HasCall =
false, HasAllocFrame =
false;
1370 while (++
T !=
End &&
T->isBundled()) {
1371 if (
T->getOpcode() == Hexagon::S2_allocframe)
1372 HasAllocFrame =
true;
1373 else if (
T->isCall())
1377 return HasCall ? It : std::next(It);
1379 return std::nullopt;
1385 insertCFIInstructionsAt(
B, *At);
1400 const MCInstrDesc &CFID = HII.get(TargetOpcode::CFI_INSTRUCTION);
1403 bool HasFP = hasFP(MF);
1406 unsigned DwFPReg = HRI.getDwarfRegNum(HRI.getFrameRegister(),
true);
1407 unsigned DwRAReg = HRI.getDwarfRegNum(HRI.getRARegister(),
true);
1434 Hexagon::R1, Hexagon::R0, Hexagon::R3, Hexagon::R2,
1435 Hexagon::R17, Hexagon::R16, Hexagon::R19, Hexagon::R18,
1436 Hexagon::R21, Hexagon::R20, Hexagon::R23, Hexagon::R22,
1437 Hexagon::R25, Hexagon::R24, Hexagon::R27, Hexagon::R26,
1438 Hexagon::D0, Hexagon::D1, Hexagon::D8, Hexagon::D9,
1439 Hexagon::D10, Hexagon::D11, Hexagon::D12, Hexagon::D13
1445 auto IfR = [
Reg] (
const CalleeSavedInfo &
C) ->
bool {
1446 return C.getReg() ==
Reg;
1465 getFrameIndexReference(MF,
F->getFrameIdx(), FrameReg).getFixed();
1471 unsigned DwarfReg = HRI.getDwarfRegNum(
Reg,
true);
1483 Register HiReg = HRI.getSubReg(
Reg, Hexagon::isub_hi);
1484 Register LoReg = HRI.getSubReg(
Reg, Hexagon::isub_lo);
1485 unsigned HiDwarfReg = HRI.getDwarfRegNum(HiReg,
true);
1486 unsigned LoDwarfReg = HRI.getDwarfRegNum(LoReg,
true);
1504 auto &HMFI = *MF.
getInfo<HexagonMachineFunctionInfo>();
1505 unsigned DwVSPReg = HRI.getDwarfRegNum(Hexagon::VSP,
true);
1506 int64_t VTCMFrameSize = HMFI.getVTCMFrameInfo().getStackSize();
1507 for (
const MCPhysReg *R = HRI.getCalleeSavedRegs(&MF); *R; ++R) {
1508 if (!Hexagon::HlxLRRegClass.
contains(*R))
1510 unsigned DwarfReg = HRI.getDwarfRegNum(*R,
true);
1512 CSI, [R](
const CalleeSavedInfo &
C) {
return C.getReg() == *
R; });
1513 if (
F == CSI.end()) {
1518 assert(HMFI.isVTCMStackIndex(
F->getFrameIdx()) &&
1519 "HLX register not spilled to the VTCM stack");
1521 VTCMFrameSize + HMFI.getMappedVTCMObjectOffset(
F->getFrameIdx());
1523 SmallString<16> Expr, Vals;
1527 Vals.
push_back(dwarf::DW_CFA_expression);
1532 (Twine(HRI.getRegAsmName(*R)) +
" at vsp + " + Twine(
Offset)).str();
1539 if (
int VSPFI = HMFI.getVSPFrameIndex(); VSPFI >= 0) {
1540 assert(HasFP &&
"A VTCM frame requires a frame pointer");
1550 bool HasExtraAlign = HRI.hasStackRealignment(MF);
1566 if (HasAlloca || HasExtraAlign)
1582 if (HMFI.getVTCMFrameInfo().getStackSize())
1597 bool Stkchk =
false) {
1598 const char * V4SpillToMemoryFunctions[] = {
1599 "__save_r16_through_r17",
1600 "__save_r16_through_r19",
1601 "__save_r16_through_r21",
1602 "__save_r16_through_r23",
1603 "__save_r16_through_r25",
1604 "__save_r16_through_r27" };
1606 const char * V4SpillToMemoryStkchkFunctions[] = {
1607 "__save_r16_through_r17_stkchk",
1608 "__save_r16_through_r19_stkchk",
1609 "__save_r16_through_r21_stkchk",
1610 "__save_r16_through_r23_stkchk",
1611 "__save_r16_through_r25_stkchk",
1612 "__save_r16_through_r27_stkchk" };
1614 const char * V4SpillFromMemoryFunctions[] = {
1615 "__restore_r16_through_r17_and_deallocframe",
1616 "__restore_r16_through_r19_and_deallocframe",
1617 "__restore_r16_through_r21_and_deallocframe",
1618 "__restore_r16_through_r23_and_deallocframe",
1619 "__restore_r16_through_r25_and_deallocframe",
1620 "__restore_r16_through_r27_and_deallocframe" };
1622 const char * V4SpillFromMemoryTailcallFunctions[] = {
1623 "__restore_r16_through_r17_and_deallocframe_before_tailcall",
1624 "__restore_r16_through_r19_and_deallocframe_before_tailcall",
1625 "__restore_r16_through_r21_and_deallocframe_before_tailcall",
1626 "__restore_r16_through_r23_and_deallocframe_before_tailcall",
1627 "__restore_r16_through_r25_and_deallocframe_before_tailcall",
1628 "__restore_r16_through_r27_and_deallocframe_before_tailcall"
1631 const char **SpillFunc =
nullptr;
1635 SpillFunc = Stkchk ? V4SpillToMemoryStkchkFunctions
1636 : V4SpillToMemoryFunctions;
1639 SpillFunc = V4SpillFromMemoryFunctions;
1642 SpillFunc = V4SpillFromMemoryTailcallFunctions;
1645 assert(SpillFunc &&
"Unknown spill kind");
1650 return SpillFunc[0];
1652 return SpillFunc[1];
1654 return SpillFunc[2];
1656 return SpillFunc[3];
1658 return SpillFunc[4];
1660 return SpillFunc[5];
1674 if (HMFI.isVTCMStackIndex(FI)) {
1676 FrameReg = HRI.getVTCMStackRegister();
1678 HMFI.getMappedVTCMObjectOffset(FI));
1683 bool HasExtraAlign = HRI.hasStackRealignment(MF);
1687 Register SP = HRI.getStackRegister();
1689 Register AP = HMFI.getStackAlignBaseReg();
1704 bool UseFP =
false, UseAP =
false;
1709 if (NoOpt && !HasExtraAlign)
1714 UseFP |= (HasAlloca || HasExtraAlign);
1725 bool HasFP =
hasFP(MF);
1726 assert((HasFP || !UseFP) &&
"This function must have frame pointer");
1752 if (
Offset > 0 && !HasFP)
1767 if (!UseFP && !UseAP)
1768 RealOffset = FrameSize+
Offset;
1774 bool &PrologueStubs)
const {
1779 PrologueStubs =
false;
1784 if (useSpillFunction(MF, CSI)) {
1785 PrologueStubs =
true;
1797 if (StkOvrFlowEnabled) {
1799 SpillOpc = IsPIC ? Hexagon::SAVE_REGISTERS_CALL_V4STK_EXT_PIC
1800 : Hexagon::SAVE_REGISTERS_CALL_V4STK_EXT;
1802 SpillOpc = IsPIC ? Hexagon::SAVE_REGISTERS_CALL_V4STK_PIC
1803 : Hexagon::SAVE_REGISTERS_CALL_V4STK;
1806 SpillOpc = IsPIC ? Hexagon::SAVE_REGISTERS_CALL_V4_EXT_PIC
1807 : Hexagon::SAVE_REGISTERS_CALL_V4_EXT;
1809 SpillOpc = IsPIC ? Hexagon::SAVE_REGISTERS_CALL_V4_PIC
1810 : Hexagon::SAVE_REGISTERS_CALL_V4;
1813 MachineInstr *SaveRegsCall =
1818 addCalleeSaveRegistersAsImpOperand(SaveRegsCall, CSI,
false,
true);
1820 for (
const CalleeSavedInfo &
I : CSI)
1823 for (
const CalleeSavedInfo &
I : CSI) {
1824 MCRegister
Reg =
I.getReg();
1829 int FI =
I.getFrameIdx();
1840bool HexagonFrameLowering::insertCSRRestoresInBlock(MachineBasicBlock &
MBB,
1841 const CSIVect &CSI,
const HexagonRegisterInfo &HRI)
const {
1850 if (useRestoreFunction(MF, CSI)) {
1855 auto &HTM =
static_cast<const HexagonTargetMachine&
>(MF.
getTarget());
1856 bool IsPIC = HTM.isPositionIndependent();
1862 MachineInstr *DeallocCall =
nullptr;
1867 RetOpc = IsPIC ? Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT_PIC
1868 : Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_EXT;
1870 RetOpc = IsPIC ? Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4_PIC
1871 : Hexagon::RESTORE_DEALLOC_BEFORE_TAILCALL_V4;
1880 RetOpc = IsPIC ? Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT_PIC
1881 : Hexagon::RESTORE_DEALLOC_RET_JMP_V4_EXT;
1883 RetOpc = IsPIC ? Hexagon::RESTORE_DEALLOC_RET_JMP_V4_PIC
1884 : Hexagon::RESTORE_DEALLOC_RET_JMP_V4;
1885 MachineInstrBuilder MIB =
1889 for (
const MachineOperand &MO :
drop_begin(It->implicit_operands()))
1893 addCalleeSaveRegistersAsImpOperand(DeallocCall, CSI,
true,
false);
1897 for (
const CalleeSavedInfo &
I : CSI) {
1898 MCRegister
Reg =
I.getReg();
1900 int FI =
I.getFrameIdx();
1911 unsigned Opc =
MI.getOpcode();
1913 assert((
Opc == Hexagon::ADJCALLSTACKDOWN ||
Opc == Hexagon::ADJCALLSTACKUP) &&
1914 "Cannot handle this call frame pseudo instruction");
1915 return MBB.erase(
I);
1918void HexagonFrameLowering::computeVTCMStackOffsets(
MachineFunction &MF)
const {
1921 const auto &HRI = *HST.getRegisterInfo();
1924 const int64_t HlxLRSize = HRI.getSpillSize(Hexagon::HlxLRRegClass);
1925 const int64_t HlxLLRSize = HRI.getSpillSize(Hexagon::HlxLLRRegClass);
1932 HMFI.moveToVTCMStack(
I, VTCMFrameInfo.CreateFixedObject(
1953 IsHlxSpill ? VTCMFrameInfo.CreateSpillStackObject(
Size, Alignment)
1954 : VTCMFrameInfo.CreateStackObject(
1957 VTCMFrameInfo.setObjectOffset(VTCMIndex, -
Offset);
1958 HMFI.moveToVTCMStack(
I, VTCMIndex);
1964 VTCMFrameInfo.setStackSize(StackSize);
1968 uint64_t Limit =
F.getFnAttributeAsParsedInteger(
"hlx-vector-stack-limit",
1970 if (StackSize > Limit)
1971 F.getContext().diagnose(DiagnosticInfoResourceLimit(
1972 F,
"HLX vector stack size", StackSize, Limit,
DS_Error));
1978 if (!HST.hasV85OpsOnly() || !HST.useHLXOps())
1980 computeVTCMStackOffsets(MF);
1982 if (
SaveParentVSP && HMFI.getVTCMFrameInfo().getStackSize())
1990 if (!HST.hasV85OpsOnly() || !HST.useHLXOps())
2010 if (
MRI.isPhysRegUsed(*AI))
2040 BitVector SRegs(Hexagon::NUM_TARGET_REGS);
2067 "AP must be assigned before register allocation");
2072 bool HasResSub =
false;
2099 BitVector TmpSup(Hexagon::NUM_TARGET_REGS);
2102 if (Hexagon::HlxLRRegClass.
contains(R))
2107 for (
int x = TmpSup.find_first(); x >= 0; x = TmpSup.find_next(x)) {
2145 int64_t MinOffset = 0;
2147 for (
const SpillSlot *S = FixedSlots; S != FixedSlots+NumFixed; ++S) {
2152 MinOffset = std::min(MinOffset, S->Offset);
2154 SRegs[S->Reg] =
false;
2163 unsigned Size =
TRI->getSpillSize(*RC);
2165 if (Hexagon::HlxLRRegClass.
contains(R)) {
2171 int64_t
Off = MinOffset -
Size;
2173 Off &= -Alignment.value();
2175 MinOffset = std::min(MinOffset,
Off);
2181 dbgs() <<
"CS information: {";
2183 int FI =
I.getFrameIdx();
2195 bool MissedReg =
false;
2215 if (!Hexagon::ModRegsRegClass.
contains(DstR) ||
2216 !Hexagon::ModRegsRegClass.
contains(SrcR))
2219 Register TmpR =
MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
2220 BuildMI(
B, It,
DL, HII.get(TargetOpcode::COPY), TmpR).
add(
MI->getOperand(1));
2221 BuildMI(
B, It,
DL, HII.get(TargetOpcode::COPY), DstR)
2233 if (!
MI->getOperand(0).isFI())
2237 unsigned Opc =
MI->getOpcode();
2239 bool IsKill =
MI->getOperand(2).isKill();
2240 int FI =
MI->getOperand(0).getIndex();
2244 Register TmpR =
MRI.createVirtualRegister(&Hexagon::IntRegsRegClass);
2245 unsigned TfrOpc = (
Opc == Hexagon::STriw_pred) ? Hexagon::C2_tfrpr
2251 BuildMI(
B, It,
DL, HII.get(Hexagon::S2_storeri_io))
2262bool HexagonFrameLowering::expandStoreCirc(
2264 MachineRegisterInfo &
MRI,
const HexagonInstrInfo &HII,
2265 SmallVectorImpl<Register> &NewRegs)
const {
2267 const auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2268 MachineInstr *
MI = &*It;
2269 if (!
MI->getOperand(0).isFI())
2274 bool IsKill =
MI->getOperand(1).isKill();
2275 int FI =
MI->getOperand(0).getIndex();
2278 for (
auto SubReg : {Hexagon::isub_lo, Hexagon::isub_hi}) {
2279 Register SrcSubReg = HRI.getSubReg(SrcR, SubReg);
2283 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_tfrcrr), TmpR)
2288 BuildMI(
B, It,
DL, HII.get(Hexagon::S2_storeri_io))
2291 .
addReg(TmpR, RegState::Kill)
2294 Offset += HRI.getSpillSize(Hexagon::IntRegsRegClass);
2301bool HexagonFrameLowering::expandLoadCirc(
2303 MachineRegisterInfo &
MRI,
const HexagonInstrInfo &HII,
2304 SmallVectorImpl<Register> &NewRegs)
const {
2306 const auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2307 MachineInstr *
MI = &*It;
2308 if (!
MI->getOperand(1).isFI())
2313 int FI =
MI->getOperand(1).getIndex();
2316 for (
auto SubReg : {Hexagon::isub_lo, Hexagon::isub_hi}) {
2317 Register DstSubReg = HRI.getSubReg(DstR, SubReg);
2321 BuildMI(
B, It,
DL, HII.get(Hexagon::L2_loadri_io), TmpR)
2327 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_tfrrcr), DstSubReg)
2328 .
addReg(TmpR, RegState::Kill)
2332 Offset += HRI.getSpillSize(Hexagon::IntRegsRegClass);
2339bool HexagonFrameLowering::expandLoadInt(
2341 MachineRegisterInfo &
MRI,
const HexagonInstrInfo &HII,
2342 SmallVectorImpl<Register> &NewRegs)
const {
2343 MachineInstr *
MI = &*It;
2344 if (!
MI->getOperand(1).isFI())
2348 unsigned Opc =
MI->getOpcode();
2350 int FI =
MI->getOperand(1).getIndex();
2354 BuildMI(
B, It,
DL, HII.get(Hexagon::L2_loadri_io), TmpR)
2361 unsigned TfrOpc = (
Opc == Hexagon::LDriw_pred) ? Hexagon::C2_tfrrp
2362 : Hexagon::A2_tfrrcr;
2364 .
addReg(TmpR, RegState::Kill);
2371bool HexagonFrameLowering::expandStoreVecPred(MachineBasicBlock &
B,
2373 const HexagonInstrInfo &HII, SmallVectorImpl<Register> &NewRegs)
const {
2374 MachineInstr *
MI = &*It;
2375 if (!
MI->getOperand(0).isFI())
2380 bool IsKill =
MI->getOperand(2).isKill();
2381 int FI =
MI->getOperand(0).getIndex();
2382 auto *RC = &Hexagon::HvxVRRegClass;
2391 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_tfrsi), TmpR0)
2394 BuildMI(
B, It,
DL, HII.get(Hexagon::V6_vandqrt), TmpR1)
2396 .
addReg(TmpR0, RegState::Kill);
2399 expandStoreVec(
B, std::prev(It),
MRI, HII, NewRegs);
2407bool HexagonFrameLowering::expandLoadVecPred(MachineBasicBlock &
B,
2409 const HexagonInstrInfo &HII, SmallVectorImpl<Register> &NewRegs)
const {
2410 MachineInstr *
MI = &*It;
2411 if (!
MI->getOperand(1).isFI())
2416 int FI =
MI->getOperand(1).getIndex();
2417 auto *RC = &Hexagon::HvxVRRegClass;
2425 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_tfrsi), TmpR0)
2428 expandLoadVec(
B, std::prev(It),
MRI, HII, NewRegs);
2430 BuildMI(
B, It,
DL, HII.get(Hexagon::V6_vandvrt), DstR)
2431 .
addReg(TmpR1, RegState::Kill)
2432 .
addReg(TmpR0, RegState::Kill);
2440bool HexagonFrameLowering::expandStoreVec2(MachineBasicBlock &
B,
2442 MachineRegisterInfo &
MRI,
2443 const HexagonInstrInfo &HII,
2444 SmallVectorImpl<Register> &NewRegs,
2448 auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2449 MachineInstr *
MI = &*It;
2450 if (!
MI->getOperand(0).isFI())
2457 LivePhysRegs LPR(HRI);
2460 for (
auto R =
B.begin(); R != It; ++R) {
2462 LPR.stepForward(*R, Clobbers);
2467 Register SrcLo = HRI.getSubReg(SrcR, Hexagon::vsub_lo);
2468 Register SrcHi = HRI.getSubReg(SrcR, Hexagon::vsub_hi);
2469 bool IsKill =
MI->getOperand(2).isKill();
2470 int FI =
MI->getOperand(0).getIndex();
2473 const MachineOperand &SrcOp =
MI->getOperand(2);
2474 unsigned Size = HRI.getSpillSize(Hexagon::HlxLRRegClass);
2475 assert(
MI->hasOneMemOperand() &&
"HLX pair spill must have one MMO");
2476 const MachineMemOperand *PairMMO = *
MI->memoperands_begin();
2480 if (LPR.contains(SrcLo)) {
2481 BuildMI(
B, It,
DL, HII.get(Hexagon::LX_S16b_pseudo))
2484 .
addReg(Hexagon::VSP, RegState::Implicit)
2488 if (LPR.contains(SrcHi)) {
2490 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_addi), StackReg)
2493 BuildMI(
B, It,
DL, HII.get(Hexagon::LX_S16b_pseudo))
2494 .
addReg(StackReg, RegState::Kill)
2496 .
addReg(Hexagon::VSP, RegState::Implicit)
2504 unsigned Size = HRI.getSpillSize(Hexagon::HvxVRRegClass);
2505 Align NeedAlign = HRI.getSpillAlign(Hexagon::HvxVRRegClass);
2510 if (LPR.contains(SrcLo)) {
2511 StoreOpc = NeedAlign <= HasAlign ? Hexagon::V6_vS32b_ai
2512 : Hexagon::V6_vS32Ub_ai;
2521 if (LPR.contains(SrcHi)) {
2522 StoreOpc = NeedAlign <= HasAlign ? Hexagon::V6_vS32b_ai
2523 : Hexagon::V6_vS32Ub_ai;
2535bool HexagonFrameLowering::expandLoadVec2(MachineBasicBlock &
B,
2537 MachineRegisterInfo &
MRI,
2538 const HexagonInstrInfo &HII,
2539 SmallVectorImpl<Register> &NewRegs,
2543 auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2544 MachineInstr *
MI = &*It;
2545 if (!
MI->getOperand(1).isFI())
2550 Register DstHi = HRI.getSubReg(DstR, Hexagon::vsub_hi);
2551 Register DstLo = HRI.getSubReg(DstR, Hexagon::vsub_lo);
2552 int FI =
MI->getOperand(1).getIndex();
2555 const MachineOperand &DstOp =
MI->getOperand(0);
2556 unsigned Size = HRI.getSpillSize(Hexagon::HlxLRRegClass);
2557 assert(
MI->hasOneMemOperand() &&
"HLX pair reload must have one MMO");
2558 const MachineMemOperand *PairMMO = *
MI->memoperands_begin();
2562 BuildMI(
B, It,
DL, HII.get(Hexagon::LX_L16b_pseudo))
2565 .
addReg(Hexagon::VSP, RegState::Implicit)
2569 BuildMI(
B, It,
DL, HII.get(Hexagon::A2_addi), StackReg)
2572 BuildMI(
B, It,
DL, HII.get(Hexagon::LX_L16b_pseudo))
2574 .
addReg(StackReg, RegState::Kill)
2575 .
addReg(Hexagon::VSP, RegState::Implicit)
2582 unsigned Size = HRI.getSpillSize(Hexagon::HvxVRRegClass);
2583 Align NeedAlign = HRI.getSpillAlign(Hexagon::HvxVRRegClass);
2588 LoadOpc = NeedAlign <= HasAlign ? Hexagon::V6_vL32b_ai
2589 : Hexagon::V6_vL32Ub_ai;
2596 LoadOpc = NeedAlign <= HasAlign ? Hexagon::V6_vL32b_ai
2597 : Hexagon::V6_vL32Ub_ai;
2607bool HexagonFrameLowering::expandStoreVec(MachineBasicBlock &
B,
2609 const HexagonInstrInfo &HII, SmallVectorImpl<Register> &NewRegs)
const {
2612 MachineInstr *
MI = &*It;
2613 if (!
MI->getOperand(0).isFI())
2616 auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2619 bool IsKill =
MI->getOperand(2).isKill();
2620 int FI =
MI->getOperand(0).getIndex();
2622 Align NeedAlign = HRI.getSpillAlign(Hexagon::HvxVRRegClass);
2624 unsigned StoreOpc = NeedAlign <= HasAlign ? Hexagon::V6_vS32b_ai
2625 : Hexagon::V6_vS32Ub_ai;
2636bool HexagonFrameLowering::expandLoadVec(MachineBasicBlock &
B,
2638 const HexagonInstrInfo &HII, SmallVectorImpl<Register> &NewRegs)
const {
2641 MachineInstr *
MI = &*It;
2642 if (!
MI->getOperand(1).isFI())
2645 auto &HRI = *MF.
getSubtarget<HexagonSubtarget>().getRegisterInfo();
2648 int FI =
MI->getOperand(1).getIndex();
2650 Align NeedAlign = HRI.getSpillAlign(Hexagon::HvxVRRegClass);
2652 unsigned LoadOpc = NeedAlign <= HasAlign ? Hexagon::V6_vL32b_ai
2653 : Hexagon::V6_vL32Ub_ai;
2664 SmallVectorImpl<Register> &NewRegs)
const {
2665 auto &HII = *MF.
getSubtarget<HexagonSubtarget>().getInstrInfo();
2669 for (
auto &
B : MF) {
2672 for (
auto I =
B.begin(),
E =
B.end();
I !=
E;
I = NextI) {
2673 MachineInstr *
MI = &*
I;
2674 NextI = std::next(
I);
2675 unsigned Opc =
MI->getOpcode();
2678 case TargetOpcode::COPY:
2681 case Hexagon::STriw_pred:
2682 case Hexagon::STriw_ctr:
2685 case Hexagon::STriw_circ:
2688 case Hexagon::LDriw_pred:
2689 case Hexagon::LDriw_ctr:
2692 case Hexagon::LDriw_circ:
2695 case Hexagon::PS_vstorerq_ai:
2696 Changed |= expandStoreVecPred(
B,
I,
MRI, HII, NewRegs);
2698 case Hexagon::PS_vloadrq_ai:
2701 case Hexagon::PS_vloadrw_ai:
2704 case Hexagon::PS_vstorerw_ai:
2707 case Hexagon::PS_loadrll:
2708 Changed |= expandLoadVec2(
B,
I,
MRI, HII, NewRegs,
true);
2710 case Hexagon::PS_storerll:
2711 Changed |= expandStoreVec2(
B,
I,
MRI, HII, NewRegs,
true);
2725 SavedRegs.
resize(HRI.getNumRegs());
2730 for (
const MCPhysReg *R = HRI.getCalleeSavedRegs(&MF); *R; ++R)
2739 assert(AP.
isValid() &&
"AP must be assigned before register allocation");
2745 expandSpillMacros(MF, NewRegs);
2747 optimizeSpillSlots(MF, NewRegs);
2751 if (!NewRegs.
empty() || mayOverflowFrameOffset(MF)) {
2757 SpillRCs.
insert(&Hexagon::IntRegsRegClass);
2762 for (
const auto *RC : SpillRCs) {
2766 switch (RC->
getID()) {
2767 case Hexagon::IntRegsRegClassID:
2770 case Hexagon::HvxQRRegClassID:
2774 unsigned S = HRI.getSpillSize(*RC);
2775 Align A = HRI.getSpillAlign(*RC);
2776 for (
unsigned i = 0; i < Num; i++) {
2778 RS->addScavengingFrameIndex(NewFI);
2795 auto F = DeadMap.find({Reg,0});
2796 if (
F == DeadMap.end())
2798 for (
auto &DR :
F->second)
2799 if (DR.contains(FIR))
2804 for (
Register Reg : HRI.getRawAllocationOrder(*RC, MF)) {
2819 SmallVectorImpl<Register> &VRegs)
const {
2821 auto &HII = *HST.getInstrInfo();
2824 HexagonBlockRanges HBR(MF);
2826 using BlockIndexMap =
2827 std::map<MachineBasicBlock *, HexagonBlockRanges::InstrIndexMap>;
2828 using BlockRangeMap =
2829 std::map<MachineBasicBlock *, HexagonBlockRanges::RangeList>;
2830 using IndexType = HexagonBlockRanges::IndexType;
2837 SlotInfo() =
default;
2840 BlockIndexMap BlockIndexes;
2841 SmallSet<int,4> BadFIs;
2842 std::map<int,SlotInfo> FIRangeMap;
2851 if (HaveRC ==
nullptr || HaveRC == NewRC)
2856 if (NewRC->hasSubClassEq(HaveRC))
2863 for (
auto &
B : MF) {
2864 std::map<int,IndexType> LastStore, LastLoad;
2865 auto P = BlockIndexes.emplace(&
B, HexagonBlockRanges::InstrIndexMap(
B));
2866 auto &IndexMap =
P.first->second;
2868 << IndexMap <<
'\n');
2870 for (
auto &In :
B) {
2874 if (
In.isDebugInstr())
2877 bool Load = HII.isLoadFromStackSlot(In, LFI) && !HII.isPredicated(In);
2878 bool Store = HII.isStoreToStackSlot(In, SFI) && !HII.isPredicated(In);
2892 int TFI =
Load ? LFI : SFI;
2893 unsigned AM = HII.getAddrMode(In);
2894 SlotInfo &
SI = FIRangeMap[TFI];
2898 unsigned OpNum =
Load ? 0 : 2;
2899 auto *RC = HII.getRegClass(
In.getDesc(), OpNum);
2900 RC = getCommonRC(
SI.RC, RC);
2908 unsigned S = HII.getMemAccessSize(In);
2909 if (
SI.Size != 0 &&
SI.Size != S)
2915 for (
auto *Mo :
In.memoperands()) {
2916 if (!Mo->isVolatile() && !Mo->isAtomic())
2927 for (
unsigned i = 0, n =
In.getNumOperands(); i < n; ++i) {
2928 const MachineOperand &
Op =
In.getOperand(i);
2931 int FI =
Op.getIndex();
2934 if (i+1 >= n || !
In.getOperand(i+1).isImm() ||
2935 In.getOperand(i+1).getImm() != 0)
2937 if (BadFIs.
count(FI))
2941 auto &
LS = LastStore[FI];
2942 auto &LL = LastLoad[FI];
2944 if (LS == IndexType::None)
2945 LS = IndexType::Entry;
2948 HexagonBlockRanges::RangeList &RL = FIRangeMap[FI].Map[&
B];
2949 if (LS != IndexType::None)
2950 RL.
add(LS, LL,
false,
false);
2951 else if (LL != IndexType::None)
2952 RL.
add(IndexType::Entry, LL,
false,
false);
2953 LL = IndexType::None;
2961 for (
auto &
I : LastLoad) {
2962 IndexType LL =
I.second;
2963 if (LL == IndexType::None)
2965 auto &RL = FIRangeMap[
I.first].Map[&
B];
2966 IndexType &
LS = LastStore[
I.first];
2967 if (LS != IndexType::None)
2968 RL.
add(LS, LL,
false,
false);
2970 RL.
add(IndexType::Entry, LL,
false,
false);
2971 LS = IndexType::None;
2973 for (
auto &
I : LastStore) {
2974 IndexType
LS =
I.second;
2975 if (LS == IndexType::None)
2977 auto &RL = FIRangeMap[
I.first].Map[&
B];
2978 RL.
add(LS, IndexType::None,
false,
false);
2983 for (
auto &
P : FIRangeMap) {
2984 dbgs() <<
"fi#" <<
P.first;
2985 if (BadFIs.
count(
P.first))
2988 if (
P.second.RC !=
nullptr)
2989 dbgs() << HRI.getRegClassName(
P.second.RC) <<
'\n';
2991 dbgs() <<
"<null>\n";
2992 for (
auto &R :
P.second.Map)
3001 SmallSet<int,4> LoxFIs;
3003 std::map<MachineBasicBlock*,std::vector<int>> BlockFIMap;
3005 for (
auto &
P : FIRangeMap) {
3007 if (BadFIs.
count(
P.first))
3009 for (
auto &
B : MF) {
3010 auto F =
P.second.Map.find(&
B);
3012 if (
F ==
P.second.Map.end() ||
F->second.empty())
3014 HexagonBlockRanges::IndexRange &
IR =
F->second.front();
3015 if (
IR.start() == IndexType::Entry)
3016 LoxFIs.insert(
P.first);
3017 BlockFIMap[&
B].push_back(
P.first);
3022 dbgs() <<
"Block-to-FI map (* -- live-on-exit):\n";
3023 for (
auto &
P : BlockFIMap) {
3024 auto &FIs =
P.second;
3028 for (
auto I : FIs) {
3029 dbgs() <<
" fi#" <<
I;
3030 if (LoxFIs.count(
I))
3042 for (
auto &
B : MF) {
3043 auto F = BlockIndexes.find(&
B);
3044 assert(
F != BlockIndexes.end());
3045 HexagonBlockRanges::InstrIndexMap &IM =
F->second;
3049 << HexagonBlockRanges::PrintRangeMap(
DM, HRI));
3051 for (
auto FI : BlockFIMap[&
B]) {
3052 if (BadFIs.
count(FI))
3055 HexagonBlockRanges::RangeList &RL = FIRangeMap[FI].Map[&
B];
3056 for (
auto &
Range : RL) {
3058 if (!IndexType::isInstr(
Range.start()) ||
3059 !IndexType::isInstr(
Range.end()))
3063 assert(
SI.mayStore() &&
"Unexpected start instruction");
3065 MachineOperand &SrcOp =
SI.getOperand(2);
3067 HexagonBlockRanges::RegisterRef SrcRR = { SrcOp.
getReg(),
3069 auto *RC = HII.getRegClass(
SI.getDesc(), 2);
3086 MachineInstr *CopyIn =
nullptr;
3087 if (SrcRR.
Reg != FoundR || SrcRR.
Sub != 0) {
3089 CopyIn =
BuildMI(
B, StartIt,
DL, HII.get(TargetOpcode::COPY), FoundR)
3095 if (LoxFIs.count(FI) && (&
Range == &RL.back())) {
3098 SrcOp.
setReg(HRI.getSubReg(FoundR, SR));
3110 for (
auto It = StartIt; It != EndIt; It = NextIt) {
3111 MachineInstr &
MI = *It;
3112 NextIt = std::next(It);
3114 if (!HII.isLoadFromStackSlot(
MI, TFI) || TFI != FI)
3117 assert(
MI.getOperand(0).getSubReg() == 0);
3118 MachineInstr *CopyOut =
nullptr;
3119 if (DstR != FoundR) {
3121 unsigned MemSize = HII.getMemAccessSize(
MI);
3123 unsigned CopyOpc = TargetOpcode::COPY;
3124 if (HII.isSignExtendingLoad(
MI))
3125 CopyOpc = (MemSize == 1) ? Hexagon::A2_sxtb : Hexagon::A2_sxth;
3126 else if (HII.isZeroExtendingLoad(
MI))
3127 CopyOpc = (MemSize == 1) ? Hexagon::A2_zxtb : Hexagon::A2_zxth;
3128 CopyOut =
BuildMI(
B, It,
DL, HII.get(CopyOpc), DstR)
3136 HexagonBlockRanges::RegisterRef FoundRR = { FoundR, 0 };
3144void HexagonFrameLowering::expandAlloca(MachineInstr *AI,
MachineFunction &MF,
3145 const HexagonInstrInfo &HII,
3147 MachineBasicBlock &MB = *AI->
getParent();
3156 auto *
TLI = HST.getTargetLowering();
3159 if (!NeedsProbing) {
3183 BuildMI(MB, AI,
DL, HII.get(Hexagon::A2_andir), Rd)
3187 BuildMI(MB, AI,
DL, HII.get(Hexagon::A2_andir), SP)
3225 unsigned ProbeSize =
TLI->getStackProbeSize(MF, StackAlign);
3230 BuildMI(MB, AI,
DL, HII.get(Hexagon::A2_sub), Rd)
3236 BuildMI(MB, AI,
DL, HII.get(Hexagon::A2_andir), Rd)
3245 MF.
insert(InsertPt, LoopMBB);
3247 MF.
insert(InsertPt, ExitMBB);
3258 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::A2_addi), Hexagon::R29)
3263 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::S4_storeiri_io))
3269 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::C2_cmpgtu),
3275 BuildMI(*LoopMBB, LoopMBB->
end(),
DL, HII.get(Hexagon::J2_jumpt))
3284 BuildMI(*ExitMBB, ExitIt,
DL, HII.get(Hexagon::A2_tfr), Hexagon::R29)
3288 BuildMI(*ExitMBB, ExitIt,
DL, HII.get(Hexagon::A2_addi), Rd)
3316void HexagonFrameLowering::addCalleeSaveRegistersAsImpOperand(
MachineInstr *
MI,
3317 const CSIVect &CSI,
bool IsDef,
bool IsKill)
const {
3328 const CSIVect &CSI)
const {
3341 BitVector Regs(Hexagon::NUM_TARGET_REGS);
3344 if (!Hexagon::DoubleRegsRegClass.
contains(R))
3348 int F = Regs.find_first();
3349 if (
F != Hexagon::D8)
3352 int N = Regs.find_next(
F);
3353 if (
N >= 0 &&
N !=
F+1)
3362 const CSIVect &CSI)
const {
3363 if (shouldInlineCSR(MF, CSI))
3365 unsigned NumCSI = CSI.size();
3384 if (HST.getSCSPReg().id() <= MaxReg.id())
3390 return Threshold < NumCSI;
3393bool HexagonFrameLowering::useRestoreFunction(
const MachineFunction &MF,
3394 const CSIVect &CSI)
const {
3395 if (shouldInlineCSR(MF, CSI))
3408 unsigned NumCSI = CSI.size();
3414 return Threshold < NumCSI;
3417bool HexagonFrameLowering::mayOverflowFrameOffset(
MachineFunction &MF)
const {
3422 if (HST.useHVXOps() && StackSize > 256)
3429 bool HasImmStack =
false;
3430 unsigned MinLS = ~0
u;
3432 for (
const MachineBasicBlock &
B : MF) {
3433 for (
const MachineInstr &
MI :
B) {
3435 switch (
MI.getOpcode()) {
3436 case Hexagon::S4_storeirit_io:
3437 case Hexagon::S4_storeirif_io:
3438 case Hexagon::S4_storeiri_io:
3441 case Hexagon::S4_storeirht_io:
3442 case Hexagon::S4_storeirhf_io:
3443 case Hexagon::S4_storeirh_io:
3446 case Hexagon::S4_storeirbt_io:
3447 case Hexagon::S4_storeirbf_io:
3448 case Hexagon::S4_storeirb_io:
3449 if (
MI.getOperand(0).isFI())
3451 MinLS = std::min(MinLS, LS);
3465struct HexagonFrameSortingObject {
3466 bool IsValid =
false;
3472struct HexagonFrameSortingComparator {
3473 inline bool operator()(
const HexagonFrameSortingObject &
A,
3474 const HexagonFrameSortingObject &
B)
const {
3475 return std::make_tuple(!
A.IsValid,
A.ObjectAlignment,
A.Size) <
3476 std::make_tuple(!
B.IsValid,
B.ObjectAlignment,
B.Size);
3486 if (ObjectsToAllocate.
empty())
3490 int NObjects = ObjectsToAllocate.
size();
3498 if (i != ObjectsToAllocate[j])
3509 SortingObjects[i].IsValid =
true;
3510 SortingObjects[i].Index = i;
3520 for (
auto &Obj : SortingObjects) {
3523 ObjectsToAllocate[--i] = Obj.Index;
const TargetLowering & TLI
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
MachineBasicBlock MachineBasicBlock::iterator MBBI
This file contains the simple types necessary to represent the attributes associated with functions a...
This file implements the BitVector class.
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static RegisterPass< DebugifyModulePass > DM("debugify", "Attach debug info to everything")
This file defines the DenseMap class.
This file contains constants used for implementing Dwarf debug support.
static MachineInstr * getReturn(MachineBasicBlock &MBB)
Returns the "return" instruction from this block, or nullptr if there isn't any.
static cl::opt< unsigned > ShrinkLimit("shrink-frame-limit", cl::init(std::numeric_limits< unsigned >::max()), cl::Hidden, cl::desc("Max count of stack frame shrink-wraps"))
static bool isOptNone(const MachineFunction &MF)
static cl::opt< int > SpillFuncThreshold("spill-func-threshold", cl::Hidden, cl::desc("Specify O2(not Os) spill func threshold"), cl::init(6))
static std::optional< MachineBasicBlock::iterator > findCFILocation(MachineBasicBlock &B)
static cl::opt< bool > EliminateFramePointer("hexagon-fp-elim", cl::init(true), cl::Hidden, cl::desc("Refrain from using FP whenever possible"))
static bool enableAllocFrameElim(const MachineFunction &MF)
static const char * getSpillFunctionFor(Register MaxReg, SpillKind SpillType, bool Stkchk=false)
static bool hasReturn(const MachineBasicBlock &MBB)
Returns true if MBB contains an instruction that returns.
static cl::opt< bool > EnableSaveRestoreLong("enable-save-restore-long", cl::Hidden, cl::desc("Enable long calls for save-restore stubs."), cl::init(false))
static bool needToReserveScavengingSpillSlots(MachineFunction &MF, const HexagonRegisterInfo &HRI, const TargetRegisterClass *RC)
Returns true if there are no caller-saved registers available in class RC.
static bool isOptSize(const MachineFunction &MF)
static Register getMax32BitSubRegister(Register Reg, const TargetRegisterInfo &TRI, bool hireg=true)
Map a register pair Reg to the subregister that has the greater "number", i.e.
static cl::opt< int > SpillFuncThresholdOs("spill-func-threshold-Os", cl::Hidden, cl::desc("Specify Os spill func threshold"), cl::init(1))
static bool needsStackFrame(const MachineBasicBlock &MBB, const BitVector &CSR, const HexagonRegisterInfo &HRI)
Checks if the basic block contains any instruction that needs a stack frame to be already in place.
static cl::opt< unsigned > HLXVectorStackLimit("hlx-vector-stack-limit", cl::Hidden, cl::init(std::numeric_limits< unsigned >::max()), cl::desc("Maximum HLX vector (VTCM) stack frame size in bytes"))
static cl::opt< bool > DisableDeallocRet("disable-hexagon-dealloc-ret", cl::Hidden, cl::desc("Disable Dealloc Return for Hexagon target"))
static cl::opt< bool > EnableShrinkWrapping("hexagon-shrink-frame", cl::init(true), cl::Hidden, cl::desc("Enable stack frame shrink wrapping"))
static bool hasTailCall(const MachineBasicBlock &MBB)
Returns true if MBB has a machine instructions that indicates a tail call in the block.
static cl::opt< unsigned > NumberScavengerSlots("number-scavenger-slots", cl::Hidden, cl::desc("Set the number of scavenger slots"), cl::init(2))
static Register getMaxCalleeSavedReg(ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo &TRI)
Returns the callee saved register with the largest id in the vector.
static bool isMinSize(const MachineFunction &MF)
static cl::opt< unsigned > SpillOptMax("spill-opt-max", cl::Hidden, cl::init(std::numeric_limits< unsigned >::max()))
static bool containsHLXObject(const llvm::HexagonSubtarget &HST, llvm::Type *Ty)
static unsigned SpillOptCount
static void dump_registers(BitVector &Regs, const TargetRegisterInfo &TRI)
static void emitSCSPrologue(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL)
static bool isRestoreCall(unsigned Opc)
static cl::opt< bool > OptimizeSpillSlots("hexagon-opt-spill", cl::Hidden, cl::init(true), cl::desc("Optimize spill slots"))
static void emitSCSEpilogue(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const DebugLoc &DL)
static cl::opt< bool > EnableStackOVFSanitizer("enable-stackovf-sanitizer", cl::Hidden, cl::desc("Enable runtime checks for stack overflow."), cl::init(false))
static cl::opt< bool > SaveParentVSP("hexagon-save-parent-vsp", cl::Hidden, cl::init(false), cl::desc("Save the caller's VSP on the stack in functions with an HLX " "vector stack frame, for debuggers"))
Legalize the Machine IR a function s Machine IR
This file implements the LivePhysRegs utility for tracking liveness of physical registers.
Register const TargetRegisterInfo * TRI
Promote Memory to Register
static MCRegister getReg(const MCDisassembler *D, unsigned RC, unsigned RegNo)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
This file builds on the ADT/GraphTraits.h file to build a generic graph post order iterator.
MachineRegisterInfo & MRI
This file declares the machine register scavenger class.
bool isDead(const MachineInstr &MI, const MachineRegisterInfo &MRI)
static bool contains(SmallPtrSetImpl< ConstantExpr * > &Cache, ConstantExpr *Expr, Constant *C)
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallSet class.
This file defines the SmallVector class.
an instruction to allocate memory on the stack
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Represent a constant reference to an array (0 or more elements consecutively in memory),...
size_t size() const
Get the array size.
bool empty() const
Check if the array is empty.
int find_first() const
Returns the index of the first set bit, -1 if none of the bits are set.
void resize(unsigned N, bool t=false)
Grow or shrink the bitvector.
BitVector & set()
Set all bits in the bitvector.
int find_next(unsigned Prev) const
Returns the index of the next set bit following the "Prev" bit.
Helper class for creating CFI instructions and inserting them into MIR.
void buildEscape(StringRef Bytes, StringRef Comment="") const
void buildRestore(MCRegister Reg) const
The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...
NodeT * findNearestCommonDominator(NodeT *A, NodeT *B) const
Find nearest common dominator basic block for basic block A and B.
bool dominates(const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
dominates - Returns true iff A dominates B.
void recalculate(ParentType &Func)
recalculate - compute a dominator tree for the given function
FunctionPass class - This class is used to implement most global optimizations.
bool hasMinSize() const
Optimize this function for minimum size (-Oz).
bool hasOptNone() const
Do not optimize this function (-O0).
bool isVarArg() const
isVarArg - Return true if this function takes a variable number of arguments.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
void replaceInstr(MachineInstr *OldMI, MachineInstr *NewMI)
IndexType getIndex(MachineInstr *MI) const
MachineInstr * getInstr(IndexType Idx) const
void add(IndexType Start, IndexType End, bool Fixed, bool TiedEnd)
void insertCFIInstructions(MachineFunction &MF) const
bool hasFPImpl(const MachineFunction &MF) const override
bool enableCalleeSaveSkip(const MachineFunction &MF) const override
Returns true if the target can safely skip saving callee-saved registers for noreturn nounwind functi...
MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator I) const override
This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...
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...
void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override
Perform most of the PEI work here:
void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS) const override
This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...
void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &ObjectsToAllocate) const override
Order the symbols in the local stack frame.
void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const override
processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...
void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const override
Replace a StackProbe stub (if any) with the actual probe code inline.
const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const override
getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...
bool needsAligna(const MachineFunction &MF) const
bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const override
assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.
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
Store the specified register of the given register class to the specified stack frame index.
const HexagonRegisterInfo & getRegisterInfo() const
void loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, Register DestReg, int FrameIndex, const TargetRegisterClass *RC, Register VReg, unsigned SubReg=0, MachineInstr::MIFlag Flags=MachineInstr::NoFlags) const override
Load the specified register of the given register class from the specified stack frame index.
Hexagon target-specific information for each MachineFunction.
void setVSPFrameIndex(int FI)
Register getStackAlignBaseReg() const
bool isEHReturnCalleeSaveReg(Register Reg) const
const MCPhysReg * getCallerSavedRegs(const MachineFunction *MF, const TargetRegisterClass *RC) const
bool isTypeForHLX(Type *VecTy) const
const HexagonInstrInfo * getInstrInfo() const override
const HexagonFrameLowering * getFrameLowering() const override
const HexagonRegisterInfo * getRegisterInfo() const override
bool isEnvironmentMusl() const
static MCCFIInstruction cfiDefCfa(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it.
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int64_t Offset, SMLoc Loc={})
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals, SMLoc Loc={}, StringRef Comment="")
.cfi_escape Allows the user to add arbitrary bytes to the unwind info.
static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register, SMLoc Loc={})
.cfi_same_value Current value of Register is the same as in the previous frame.
LLVM_ABI MCSymbol * createTempSymbol()
Create a temporary symbol with a unique name.
Describe properties that are true of each instruction in the target description file.
MCRegAliasIterator enumerates all registers aliasing Reg.
unsigned getID() const
getID() - Return the register class ID number.
bool hasSubClassEq(const MCRegisterClass *RC) const
Returns true if RC is a sub-class of or equal to this class.
Wrapper class representing physical registers. Should be passed by value.
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
LLVM_ABI void transferSuccessorsAndUpdatePHIs(MachineBasicBlock *FromMBB)
Transfers all the successors, as in transferSuccessors, and update PHI operands in the successor bloc...
MachineInstrBundleIterator< const MachineInstr > const_iterator
int getNumber() const
MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...
const BasicBlock * getBasicBlock() const
Return the LLVM basic block that this instance corresponded to originally.
LLVM_ABI iterator getFirstTerminator()
Returns an iterator to the first terminator instruction of this basic block.
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.
void addLiveIn(MCRegister PhysReg, LaneBitmask LaneMask=LaneBitmask::getAll())
Adds the specified register as a live in.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
LLVM_ABI instr_iterator erase(instr_iterator I)
Remove an instruction from the instruction list and delete it.
iterator_range< succ_iterator > successors()
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
LLVM_ABI bool isLiveIn(MCRegister Reg, LaneBitmask LaneMask=LaneBitmask::getAll()) const
Return true if the specified register is in the live in set.
bool dominates(const MachineInstr *A, const MachineInstr *B) const
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.
void setMaxCallFrameSize(uint64_t S)
bool hasVarSizedObjects() const
This method may be called any time after instruction selection is complete to determine if the stack ...
bool isObjectPreAllocated(int ObjectIdx) const
Return true if the object was pre-allocated into the local block.
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects.
const AllocaInst * getObjectAllocation(int ObjectIdx) const
Return the underlying Alloca of the specified stack object if it exists.
bool hasCalls() const
Return true if the current function has any function calls.
Align getMaxAlign() const
Return alignment of this function's frame.
uint64_t getMaxCallFrameSize() const
Return the maximum size of a call frame that must be allocated for an outgoing function call.
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.
bool isSpillSlotObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a spill slot.
int64_t getObjectSize(int ObjectIdx) const
Return the size of the specified object.
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.
void RemoveStackObject(int ObjectIdx)
Remove or mark dead a statically sized stack object.
bool isVariableSizedObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a variable sized object.
int getObjectIndexEnd() const
Return one past the maximum frame object index.
LLVM_ABI int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)
Create a spill slot at a fixed location on the stack.
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.
int getObjectIndexBegin() const
Return the minimum frame object index.
bool isDeadObjectIndex(int ObjectIdx) const
Returns true if the specified index corresponds to a dead object.
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
Properties which a MachineFunction may have at a given point in time.
unsigned addFrameInst(const MCCFIInstruction &Inst)
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
StringRef getName() const
getName - Return the name of the corresponding LLVM function.
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.
MCContext & getContext() const
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
MachineBasicBlock * getBlockNumbered(unsigned N) const
getBlockNumbered - MachineBasicBlocks are automatically numbered when they are inserted into the mach...
Function & getFunction()
Return the LLVM function that this machine code represents.
unsigned getNumBlockIDs() const
getNumBlockIDs - Return the number of MBB ID's allocated.
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
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.
MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)
CreateMachineInstr - Allocate a new MachineInstr.
void insert(iterator MBBI, MachineBasicBlock *MBB)
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
const MachineInstrBuilder & addExternalSymbol(const char *FnName, unsigned TargetFlags=0) const
const MachineInstrBuilder & addCFIIndex(unsigned CFIIndex) 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 & addFrameIndex(int Idx) const
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 & cloneMemRefs(const MachineInstr &OtherMI) const
const MachineInstrBuilder & setMIFlags(unsigned Flags) const
const MachineInstrBuilder & addMemOperand(MachineMemOperand *MMO) const
instr_iterator getInstrIterator() const
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
bool isReturn(QueryType Type=AnyInBundle) const
const MachineBasicBlock * getParent() const
LLVM_ABI void addOperand(MachineFunction &MF, const MachineOperand &Op)
Add the specified operand to the instruction.
mop_range implicit_operands()
LLVM_ABI void copyImplicitOps(MachineFunction &MF, const MachineInstr &MI)
Copy implicit register operands from specified instruction to this instruction.
bool mayLoad(QueryType Type=AnyInBundle) const
Return true if this instruction could possibly read memory.
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
const MachineOperand & getOperand(unsigned i) const
@ MOStore
The memory access writes data.
MachineOperand class - Representation of each machine instruction operand.
void setSubReg(unsigned subReg)
unsigned getSubReg() const
LLVM_ABI void setReg(Register Reg)
Change the register this operand corresponds to.
void setIsKill(bool Val=true)
Register getReg() const
getReg - Returns the register number.
static MachineOperand CreateReg(Register Reg, bool isDef, bool isImp=false, bool isKill=false, bool isDead=false, bool isUndef=false, bool isEarlyClobber=false, unsigned SubReg=0, bool isDebug=false, bool isInternalRead=false, bool isRenamable=false)
LLVM_ABI MachineBasicBlock * findNearestCommonDominator(ArrayRef< MachineBasicBlock * > Blocks) const
Returns the nearest common dominator of the given blocks.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
LLVM_ABI Register createVirtualRegister(const TargetRegisterClass *RegClass, StringRef Name="")
createVirtualRegister - Create and return a new virtual register in the function with the specified r...
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
A vector that has set insertion semantics.
size_type size() const
Determine the number of elements in the SetVector.
bool insert(const value_type &X)
Insert a new element into the SetVector.
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
std::pair< const_iterator, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
void append(StringRef RHS)
Append from a 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.
int64_t getFixed() const
Returns the fixed component of the stack.
Represent a constant reference to a string, i.e.
LLVM_ABI std::string lower() const
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...
Align getStackAlign() const
getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...
const TargetRegisterInfo & getRegisterInfo() const
virtual bool hasInlineStackProbe(const MachineFunction &MF) const
CodeGenOptLevel getOptLevel() const
Returns the optimization level: None, Less, Default, or Aggressive.
bool isPositionIndependent() const
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
virtual const TargetInstrInfo * getInstrInfo() const
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
self_iterator getIterator()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
void stable_sort(R &&Range)
MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)
Builder interface. Specify how to create the initial instruction itself.
@ Kill
The last use of a register.
constexpr RegState getKillRegState(bool B)
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
@ Load
The value being inserted comes from a load (InsertElement only).
@ Store
The extracted value is stored (ExtractElement only).
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
FunctionPass * createHexagonCallFrameInformation()
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
constexpr uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
RegState getRegState(const MachineOperand &RegOp)
Get all register state flags from machine operand RegOp.
uint16_t MCPhysReg
An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Count
DWARFExpression::Operation Op
unsigned encodeSLEB128(int64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a SLEB128 value to an output stream.
auto find_if(R &&Range, UnaryPredicate P)
Provide wrappers to std::find_if which take ranges instead of having to pass begin/end explicitly.
MaybeAlign getStackAlign(const Function &F, unsigned Index)
unsigned encodeULEB128(uint64_t Value, raw_ostream &OS, unsigned PadTo=0)
Utility function to encode a ULEB128 value to an output stream.
@ End
Run the machine verifier once, at the end of the pipeline.
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.
LLVM_ABI Printable printMBBReference(const MachineBasicBlock &MBB)
Prints a machine basic block reference.
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 RegisterSet expandToSubRegs(RegisterRef R, const MachineRegisterInfo &MRI, const TargetRegisterInfo &TRI)
std::map< RegisterRef, RangeList > RegToRangeMap
static LLVM_ABI MachinePointerInfo getStack(MachineFunction &MF, int64_t Offset, uint8_t ID=0)
Stack pointer relative access.