Lines Matching defs:MRI
46 Register llvm::constrainRegToClass(MachineRegisterInfo &MRI,
50 if (!RBI.constrainGenericRegister(Reg, RegClass, MRI))
51 return MRI.createVirtualRegister(&RegClass);
58 MachineRegisterInfo &MRI, const TargetInstrInfo &TII,
69 auto *OldRegClass = MRI.getRegClassOrNull(Reg);
70 Register ConstrainedReg = constrainRegToClass(MRI, TII, RBI, Reg, RegClass);
95 } else if (OldRegClass != MRI.getRegClassOrNull(Reg)) {
98 MachineInstr *RegDef = MRI.getVRegDef(Reg);
101 Observer->changingAllUsesOfReg(MRI, Reg);
110 MachineRegisterInfo &MRI, const TargetInstrInfo &TII,
129 OpRC, TRI.getConstrainedRegClassForOperand(RegMO, MRI)))
151 return constrainOperandRegClass(MF, TRI, MRI, TII, RBI, InsertPt, *OpRC,
163 MachineRegisterInfo &MRI = MF.getRegInfo();
188 constrainOperandRegClass(MF, TRI, MRI, TII, RBI, I, I.getDesc(), MO, OpI);
202 MachineRegisterInfo &MRI) {
207 if (MRI.getType(DstReg) != MRI.getType(SrcReg))
211 const auto &DstRBC = MRI.getRegClassOrRegBank(DstReg);
212 if (!DstRBC || DstRBC == MRI.getRegClassOrRegBank(SrcReg))
217 return DstRBC.is<const RegisterBank *>() && MRI.getRegClassOrNull(SrcReg) &&
219 *MRI.getRegClassOrNull(SrcReg));
223 const MachineRegisterInfo &MRI) {
245 if (Reg.isPhysical() || !MRI.use_nodbg_empty(Reg))
296 const MachineRegisterInfo &MRI) {
298 VReg, MRI, /*LookThroughInstrs*/ false);
307 llvm::getIConstantVRegSExtVal(Register VReg, const MachineRegisterInfo &MRI) {
308 std::optional<APInt> Val = getIConstantVRegVal(VReg, MRI);
329 getConstantVRegValWithLookThrough(Register VReg, const MachineRegisterInfo &MRI,
335 while ((MI = MRI.getVRegDef(VReg)) && !IsConstantOpcode(MI) &&
347 MRI.getType(MI->getOperand(0).getReg()).getSizeInBits()));
427 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
429 VReg, MRI, LookThroughInstrs);
433 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs,
437 VReg, MRI, LookThroughInstrs, LookThroughAnyExt);
441 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
444 VReg, MRI, LookThroughInstrs);
447 return FPValueAndVReg{getConstantFPVRegVal(Reg->VReg, MRI)->getValueAPF(),
452 llvm::getConstantFPVRegVal(Register VReg, const MachineRegisterInfo &MRI) {
453 MachineInstr *MI = MRI.getVRegDef(VReg);
460 llvm::getDefSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI) {
462 auto *DefMI = MRI.getVRegDef(Reg);
463 auto DstTy = MRI.getType(DefMI->getOperand(0).getReg());
469 auto SrcTy = MRI.getType(SrcReg);
472 DefMI = MRI.getVRegDef(SrcReg);
480 const MachineRegisterInfo &MRI) {
482 getDefSrcRegIgnoringCopies(Reg, MRI);
487 const MachineRegisterInfo &MRI) {
489 getDefSrcRegIgnoringCopies(Reg, MRI);
496 MachineRegisterInfo &MRI) {
498 VRegs.push_back(MRI.createGenericVirtualRegister(Ty));
506 MachineRegisterInfo &MRI) {
517 VRegs.push_back(MRI.createGenericVirtualRegister(MainTy));
542 MIRBuilder, MRI);
571 MRI);
575 LeftoverTy = MRI.getType(LeftoverRegs[0]);
582 Register NewReg = MRI.createGenericVirtualRegister(MainTy);
589 Register NewReg = MRI.createGenericVirtualRegister(LeftoverTy);
600 MachineRegisterInfo &MRI) {
601 LLT RegTy = MRI.getType(Reg);
613 MRI);
619 extractParts(Reg, EltTy, RegNumElts, Elts, MIRBuilder, MRI);
640 const MachineRegisterInfo &MRI) {
641 MachineInstr *DefMI = getDefIgnoringCopies(Reg, MRI);
661 const MachineRegisterInfo &MRI) {
662 auto MaybeOp2Cst = getAnyConstantVRegValWithLookThrough(Op2, MRI, false);
666 auto MaybeOp1Cst = getAnyConstantVRegValWithLookThrough(Op1, MRI, false);
728 const Register Op2, const MachineRegisterInfo &MRI) {
729 const ConstantFP *Op2Cst = getConstantFPVRegVal(Op2, MRI);
733 const ConstantFP *Op1Cst = getConstantFPVRegVal(Op1, MRI);
783 const MachineRegisterInfo &MRI) {
784 auto *SrcVec2 = getOpcodeDef<GBuildVector>(Op2, MRI);
788 auto *SrcVec1 = getOpcodeDef<GBuildVector>(Op1, MRI);
795 SrcVec2->getSourceReg(Idx), MRI);
803 bool llvm::isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
805 const MachineInstr *DefMI = MRI.getVRegDef(Val);
814 if (const ConstantFP *FPVal = getConstantFPVRegVal(Val, MRI)) {
821 if (!isKnownNeverNaN(Op.getReg(), MRI, SNaN))
856 return (isKnownNeverNaN(DefMI->getOperand(1).getReg(), MRI) &&
857 isKnownNeverSNaN(DefMI->getOperand(2).getReg(), MRI)) ||
858 (isKnownNeverSNaN(DefMI->getOperand(1).getReg(), MRI) &&
859 isKnownNeverNaN(DefMI->getOperand(2).getReg(), MRI));
865 return isKnownNeverNaN(DefMI->getOperand(1).getReg(), MRI, SNaN) ||
866 isKnownNeverNaN(DefMI->getOperand(2).getReg(), MRI, SNaN);
909 MachineRegisterInfo &MRI = MF.getRegInfo();
910 Register LiveIn = MRI.getLiveInVirtReg(PhysReg);
912 MachineInstr *Def = MRI.getVRegDef(LiveIn);
926 MRI.setType(LiveIn, RegTy);
938 const MachineRegisterInfo &MRI) {
939 auto MaybeOp1Cst = getIConstantVRegVal(Op1, MRI);
945 LLT Ty = MRI.getType(Op1);
955 const MachineRegisterInfo &MRI) {
956 std::optional<APInt> Val = getIConstantVRegVal(Op0, MRI);
978 const MachineRegisterInfo &MRI) {
980 if (auto MaybeSrcVal = getIConstantVRegVal(Src, MRI)) {
990 llvm::ConstantFoldCountZeros(Register Src, const MachineRegisterInfo &MRI,
992 LLT Ty = MRI.getType(Src);
995 auto MaybeCst = getIConstantVRegVal(R, MRI);
1002 auto *BV = getOpcodeDef<GBuildVector>(Src, MRI);
1023 const MachineRegisterInfo &MRI) {
1024 LLT Ty = MRI.getType(Op1);
1025 if (Ty != MRI.getType(Op2))
1028 auto TryFoldScalar = [&MRI, Pred](Register LHS,
1030 auto LHSCst = getIConstantVRegVal(LHS, MRI);
1031 auto RHSCst = getIConstantVRegVal(RHS, MRI);
1065 auto *BV1 = getOpcodeDef<GBuildVector>(Op1, MRI);
1066 auto *BV2 = getOpcodeDef<GBuildVector>(Op2, MRI);
1089 bool llvm::isKnownToBeAPowerOfTwo(Register Reg, const MachineRegisterInfo &MRI,
1092 getDefSrcRegIgnoringCopies(Reg, MRI);
1097 const LLT Ty = MRI.getType(Reg);
1110 if (auto ConstLHS = getIConstantVRegVal(MI.getOperand(1).getReg(), MRI)) {
1118 if (auto ConstLHS = getIConstantVRegVal(MI.getOperand(1).getReg(), MRI)) {
1129 if (!isKnownToBeAPowerOfTwo(MO.getReg(), MRI, KB))
1139 auto Const = getIConstantVRegVal(MO.getReg(), MRI);
1336 const MachineRegisterInfo &MRI,
1338 MachineInstr *MI = getDefIgnoringCopies(VReg, MRI);
1353 ? getAnyConstantSplat(Element, MRI, AllowUndef)
1354 : getAnyConstantVRegValWithLookThrough(Element, MRI, true, true);
1358 if (AllowUndef && isa<GImplicitDef>(MRI.getVRegDef(Element)))
1378 const MachineRegisterInfo &MRI,
1380 if (auto SplatValAndReg = getAnyConstantSplat(Reg, MRI, AllowUndef))
1381 return mi_match(SplatValAndReg->VReg, MRI, m_SpecificICst(SplatValue));
1386 const MachineRegisterInfo &MRI,
1388 return isBuildVectorConstantSplat(MI.getOperand(0).getReg(), MRI, SplatValue,
1393 llvm::getIConstantSplatVal(const Register Reg, const MachineRegisterInfo &MRI) {
1395 getAnyConstantSplat(Reg, MRI, /* AllowUndef */ false)) {
1397 getIConstantVRegValWithLookThrough(SplatValAndReg->VReg, MRI))
1406 const MachineRegisterInfo &MRI) {
1407 return getIConstantSplatVal(MI.getOperand(0).getReg(), MRI);
1412 const MachineRegisterInfo &MRI) {
1414 getAnyConstantSplat(Reg, MRI, /* AllowUndef */ false))
1415 return getIConstantVRegSExtVal(SplatValAndReg->VReg, MRI);
1421 const MachineRegisterInfo &MRI) {
1422 return getIConstantSplatSExtVal(MI.getOperand(0).getReg(), MRI);
1426 llvm::getFConstantSplat(Register VReg, const MachineRegisterInfo &MRI,
1428 if (auto SplatValAndReg = getAnyConstantSplat(VReg, MRI, AllowUndef))
1429 return getFConstantVRegValWithLookThrough(SplatValAndReg->VReg, MRI);
1434 const MachineRegisterInfo &MRI,
1436 return isBuildVectorConstantSplat(MI, MRI, 0, AllowUndef);
1440 const MachineRegisterInfo &MRI,
1442 return isBuildVectorConstantSplat(MI, MRI, -1, AllowUndef);
1446 llvm::getVectorSplat(const MachineInstr &MI, const MachineRegisterInfo &MRI) {
1450 if (auto Splat = getIConstantSplatSExtVal(MI, MRI))
1460 const MachineRegisterInfo &MRI,
1480 const MachineRegisterInfo &MRI) {
1482 if (auto C = getIConstantVRegValWithLookThrough(Def, MRI))
1488 if (getIConstantVRegValWithLookThrough(BV->getSourceReg(SrcIdx), MRI) ||
1489 getOpcodeDef<GImplicitDef>(BV->getSourceReg(SrcIdx), MRI))
1497 const MachineRegisterInfo &MRI,
1499 if (isConstantScalar(MI, MRI, AllowFP, AllowOpaqueConstants))
1507 const MachineInstr *ElementDef = MRI.getVRegDef(MI.getOperand(I).getReg());
1508 if (!isConstantScalar(*ElementDef, MRI, AllowFP, AllowOpaqueConstants))
1517 const MachineRegisterInfo &MRI) {
1519 if (auto C = getIConstantVRegValWithLookThrough(Def, MRI))
1521 auto MaybeCst = getIConstantSplatSExtVal(MI, MRI);
1524 const unsigned ScalarSize = MRI.getType(Def).getScalarSizeInBits();
1529 const MachineRegisterInfo &MRI, bool AllowUndefs) {
1542 return isBuildVectorAllZeros(MI, MRI);
1547 const MachineRegisterInfo &MRI,
1557 return isBuildVectorAllOnes(MI, MRI);
1562 const MachineRegisterInfo &MRI, Register Reg,
1565 const MachineInstr *Def = getDefIgnoringCopies(Reg, MRI);
1578 const MachineInstr *SrcDef = getDefIgnoringCopies(SrcElt, MRI);
1637 void llvm::saveUsesAndErase(MachineInstr &MI, MachineRegisterInfo &MRI,
1642 DeadInstChain.insert(MRI.getVRegDef(Op.getReg()));
1652 MachineRegisterInfo &MRI,
1656 saveUsesAndErase(*MI, MRI, LocObserver, DeadInstChain);
1660 if (!isTriviallyDead(*Inst, MRI))
1662 saveUsesAndErase(*Inst, MRI, LocObserver, DeadInstChain);
1666 void llvm::eraseInstr(MachineInstr &MI, MachineRegisterInfo &MRI,
1668 return eraseInstrs({&MI}, MRI, LocObserver);
1671 void llvm::salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI) {
1676 for (auto &MOUse : MRI.use_operands(Def.getReg())) {
1685 salvageDebugInfoForDbgValue(MRI, MI, DbgUsers);
1743 const MachineRegisterInfo &MRI) {
1744 LLT Ty = MRI.getType(ShiftAmount);
1751 getIConstantVRegValWithLookThrough(ShiftAmount, MRI);
1757 GBuildVector *BV = getOpcodeDef<GBuildVector>(ShiftAmount, MRI);
1764 getIConstantVRegValWithLookThrough(BV->getSourceReg(I), MRI);
1790 static bool canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
1793 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1809 !shiftAmountKnownInRange(RegDef->getOperand(2).getReg(), MRI);
1842 !shiftAmountKnownInRange(RegDef->getOperand(2).getReg(), MRI);
1847 getIConstantVRegValWithLookThrough(Insert->getIndexReg(), MRI);
1850 LLT VecTy = MRI.getType(Insert->getVectorReg());
1859 getIConstantVRegValWithLookThrough(Extract->getIndexReg(), MRI);
1862 LLT VecTy = MRI.getType(Extract->getVectorReg());
1893 const MachineRegisterInfo &MRI,
1899 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1913 if (!::isGuaranteedNotToBeUndefOrPoison(BV->getSourceReg(I), MRI,
1922 if (!::isGuaranteedNotToBeUndefOrPoison(Phi->getIncomingValue(I), MRI,
1931 return ::isGuaranteedNotToBeUndefOrPoison(MO.getReg(), MRI, Depth + 1,
1934 return !::canCreateUndefOrPoison(Reg, MRI,
1941 bool llvm::canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
1943 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
1947 bool canCreatePoison(Register Reg, const MachineRegisterInfo &MRI,
1949 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
1954 const MachineRegisterInfo &MRI,
1956 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
1961 const MachineRegisterInfo &MRI,
1963 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
1968 const MachineRegisterInfo &MRI,
1970 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,