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 isa<const RegisterBank *>(DstRBC) && MRI.getRegClassOrNull(SrcReg) &&
219 *MRI.getRegClassOrNull(SrcReg));
223 const MachineRegisterInfo &MRI) {
229 if (Reg.isPhysical() || !MRI.use_nodbg_empty(Reg))
295 const MachineRegisterInfo &MRI) {
297 VReg, MRI, /*LookThroughInstrs*/ false);
306 const MachineRegisterInfo &MRI) {
307 MachineInstr *Const = MRI.getVRegDef(Reg);
314 llvm::getIConstantVRegSExtVal(Register VReg, const MachineRegisterInfo &MRI) {
315 std::optional<APInt> Val = getIConstantVRegVal(VReg, MRI);
336 getConstantVRegValWithLookThrough(Register VReg, const MachineRegisterInfo &MRI,
342 while ((MI = MRI.getVRegDef(VReg)) && !IsConstantOpcode(MI) &&
354 MRI.getType(MI->getOperand(0).getReg()).getSizeInBits()));
434 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
436 VReg, MRI, LookThroughInstrs);
440 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs,
444 VReg, MRI, LookThroughInstrs, LookThroughAnyExt);
448 Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
451 VReg, MRI, LookThroughInstrs);
454 return FPValueAndVReg{getConstantFPVRegVal(Reg->VReg, MRI)->getValueAPF(),
459 llvm::getConstantFPVRegVal(Register VReg, const MachineRegisterInfo &MRI) {
460 MachineInstr *MI = MRI.getVRegDef(VReg);
467 llvm::getDefSrcRegIgnoringCopies(Register Reg, const MachineRegisterInfo &MRI) {
469 auto *DefMI = MRI.getVRegDef(Reg);
470 auto DstTy = MRI.getType(DefMI->getOperand(0).getReg());
476 auto SrcTy = MRI.getType(SrcReg);
479 DefMI = MRI.getVRegDef(SrcReg);
487 const MachineRegisterInfo &MRI) {
489 getDefSrcRegIgnoringCopies(Reg, MRI);
494 const MachineRegisterInfo &MRI) {
496 getDefSrcRegIgnoringCopies(Reg, MRI);
503 MachineRegisterInfo &MRI) {
505 VRegs.push_back(MRI.createGenericVirtualRegister(Ty));
513 MachineRegisterInfo &MRI) {
524 VRegs.push_back(MRI.createGenericVirtualRegister(MainTy));
548 MIRBuilder, MRI);
577 MRI);
581 LeftoverTy = MRI.getType(LeftoverRegs[0]);
588 Register NewReg = MRI.createGenericVirtualRegister(MainTy);
595 Register NewReg = MRI.createGenericVirtualRegister(LeftoverTy);
606 MachineRegisterInfo &MRI) {
607 LLT RegTy = MRI.getType(Reg);
619 MRI);
625 extractParts(Reg, EltTy, RegNumElts, Elts, MIRBuilder, MRI);
646 const MachineRegisterInfo &MRI) {
647 MachineInstr *DefMI = getDefIgnoringCopies(Reg, MRI);
667 const MachineRegisterInfo &MRI) {
668 auto MaybeOp2Cst = getAnyConstantVRegValWithLookThrough(Op2, MRI, false);
672 auto MaybeOp1Cst = getAnyConstantVRegValWithLookThrough(Op1, MRI, false);
734 const Register Op2, const MachineRegisterInfo &MRI) {
735 const ConstantFP *Op2Cst = getConstantFPVRegVal(Op2, MRI);
739 const ConstantFP *Op1Cst = getConstantFPVRegVal(Op1, MRI);
789 const MachineRegisterInfo &MRI) {
790 auto *SrcVec2 = getOpcodeDef<GBuildVector>(Op2, MRI);
794 auto *SrcVec1 = getOpcodeDef<GBuildVector>(Op1, MRI);
801 SrcVec2->getSourceReg(Idx), MRI);
809 bool llvm::isKnownNeverNaN(Register Val, const MachineRegisterInfo &MRI,
811 const MachineInstr *DefMI = MRI.getVRegDef(Val);
820 if (const ConstantFP *FPVal = getConstantFPVRegVal(Val, MRI)) {
827 if (!isKnownNeverNaN(Op.getReg(), MRI, SNaN))
863 return (isKnownNeverNaN(DefMI->getOperand(1).getReg(), MRI) &&
864 isKnownNeverSNaN(DefMI->getOperand(2).getReg(), MRI)) ||
865 (isKnownNeverSNaN(DefMI->getOperand(1).getReg(), MRI) &&
866 isKnownNeverNaN(DefMI->getOperand(2).getReg(), MRI));
872 return isKnownNeverNaN(DefMI->getOperand(1).getReg(), MRI, SNaN) ||
873 isKnownNeverNaN(DefMI->getOperand(2).getReg(), MRI, SNaN);
916 MachineRegisterInfo &MRI = MF.getRegInfo();
917 Register LiveIn = MRI.getLiveInVirtReg(PhysReg);
919 MachineInstr *Def = MRI.getVRegDef(LiveIn);
933 MRI.setType(LiveIn, RegTy);
945 const MachineRegisterInfo &MRI) {
946 auto MaybeOp1Cst = getIConstantVRegVal(Op1, MRI);
952 LLT Ty = MRI.getType(Op1);
962 const MachineRegisterInfo &MRI) {
963 std::optional<APInt> Val = getIConstantVRegVal(Op0, MRI);
985 const MachineRegisterInfo &MRI) {
987 if (auto MaybeSrcVal = getIConstantVRegVal(Src, MRI)) {
997 llvm::ConstantFoldCountZeros(Register Src, const MachineRegisterInfo &MRI,
999 LLT Ty = MRI.getType(Src);
1002 auto MaybeCst = getIConstantVRegVal(R, MRI);
1009 auto *BV = getOpcodeDef<GBuildVector>(Src, MRI);
1030 const MachineRegisterInfo &MRI) {
1031 LLT Ty = MRI.getType(Op1);
1032 if (Ty != MRI.getType(Op2))
1035 auto TryFoldScalar = [&MRI, Pred](Register LHS,
1037 auto LHSCst = getIConstantVRegVal(LHS, MRI);
1038 auto RHSCst = getIConstantVRegVal(RHS, MRI);
1072 auto *BV1 = getOpcodeDef<GBuildVector>(Op1, MRI);
1073 auto *BV2 = getOpcodeDef<GBuildVector>(Op2, MRI);
1096 bool llvm::isKnownToBeAPowerOfTwo(Register Reg, const MachineRegisterInfo &MRI,
1099 getDefSrcRegIgnoringCopies(Reg, MRI);
1104 const LLT Ty = MRI.getType(Reg);
1117 if (auto ConstLHS = getIConstantVRegVal(MI.getOperand(1).getReg(), MRI)) {
1125 if (auto ConstLHS = getIConstantVRegVal(MI.getOperand(1).getReg(), MRI)) {
1136 if (!isKnownToBeAPowerOfTwo(MO.getReg(), MRI, KB))
1146 auto Const = getIConstantVRegVal(MO.getReg(), MRI);
1343 const MachineRegisterInfo &MRI,
1345 MachineInstr *MI = getDefIgnoringCopies(VReg, MRI);
1360 ? getAnyConstantSplat(Element, MRI, AllowUndef)
1361 : getAnyConstantVRegValWithLookThrough(Element, MRI, true, true);
1365 if (AllowUndef && isa<GImplicitDef>(MRI.getVRegDef(Element)))
1385 const MachineRegisterInfo &MRI,
1387 if (auto SplatValAndReg = getAnyConstantSplat(Reg, MRI, AllowUndef))
1388 return mi_match(SplatValAndReg->VReg, MRI, m_SpecificICst(SplatValue));
1393 const MachineRegisterInfo &MRI,
1395 return isBuildVectorConstantSplat(MI.getOperand(0).getReg(), MRI, SplatValue,
1400 llvm::getIConstantSplatVal(const Register Reg, const MachineRegisterInfo &MRI) {
1402 getAnyConstantSplat(Reg, MRI, /* AllowUndef */ false)) {
1404 getIConstantVRegValWithLookThrough(SplatValAndReg->VReg, MRI))
1413 const MachineRegisterInfo &MRI) {
1414 return getIConstantSplatVal(MI.getOperand(0).getReg(), MRI);
1419 const MachineRegisterInfo &MRI) {
1421 getAnyConstantSplat(Reg, MRI, /* AllowUndef */ false))
1422 return getIConstantVRegSExtVal(SplatValAndReg->VReg, MRI);
1428 const MachineRegisterInfo &MRI) {
1429 return getIConstantSplatSExtVal(MI.getOperand(0).getReg(), MRI);
1433 llvm::getFConstantSplat(Register VReg, const MachineRegisterInfo &MRI,
1435 if (auto SplatValAndReg = getAnyConstantSplat(VReg, MRI, AllowUndef))
1436 return getFConstantVRegValWithLookThrough(SplatValAndReg->VReg, MRI);
1441 const MachineRegisterInfo &MRI,
1443 return isBuildVectorConstantSplat(MI, MRI, 0, AllowUndef);
1447 const MachineRegisterInfo &MRI,
1449 return isBuildVectorConstantSplat(MI, MRI, -1, AllowUndef);
1453 llvm::getVectorSplat(const MachineInstr &MI, const MachineRegisterInfo &MRI) {
1457 if (auto Splat = getIConstantSplatSExtVal(MI, MRI))
1467 const MachineRegisterInfo &MRI,
1487 const MachineRegisterInfo &MRI) {
1489 if (auto C = getIConstantVRegValWithLookThrough(Def, MRI))
1495 if (getIConstantVRegValWithLookThrough(BV->getSourceReg(SrcIdx), MRI) ||
1496 getOpcodeDef<GImplicitDef>(BV->getSourceReg(SrcIdx), MRI))
1504 const MachineRegisterInfo &MRI,
1506 if (isConstantScalar(MI, MRI, AllowFP, AllowOpaqueConstants))
1514 const MachineInstr *ElementDef = MRI.getVRegDef(MI.getOperand(I).getReg());
1515 if (!isConstantScalar(*ElementDef, MRI, AllowFP, AllowOpaqueConstants))
1524 const MachineRegisterInfo &MRI) {
1526 if (auto C = getIConstantVRegValWithLookThrough(Def, MRI))
1528 auto MaybeCst = getIConstantSplatSExtVal(MI, MRI);
1531 const unsigned ScalarSize = MRI.getType(Def).getScalarSizeInBits();
1537 const MachineRegisterInfo &MRI) {
1539 if (auto FpConst = getFConstantVRegValWithLookThrough(Def, MRI))
1541 auto MaybeCstFP = getFConstantSplat(Def, MRI, /*allowUndef=*/false);
1548 const MachineRegisterInfo &MRI, bool AllowUndefs) {
1561 return isBuildVectorAllZeros(MI, MRI);
1566 const MachineRegisterInfo &MRI,
1576 return isBuildVectorAllOnes(MI, MRI);
1581 const MachineRegisterInfo &MRI, Register Reg,
1584 const MachineInstr *Def = getDefIgnoringCopies(Reg, MRI);
1597 const MachineInstr *SrcDef = getDefIgnoringCopies(SrcElt, MRI);
1649 void llvm::saveUsesAndErase(MachineInstr &MI, MachineRegisterInfo &MRI,
1654 DeadInstChain.insert(MRI.getVRegDef(Op.getReg()));
1664 MachineRegisterInfo &MRI,
1668 saveUsesAndErase(*MI, MRI, LocObserver, DeadInstChain);
1672 if (!isTriviallyDead(*Inst, MRI))
1674 saveUsesAndErase(*Inst, MRI, LocObserver, DeadInstChain);
1678 void llvm::eraseInstr(MachineInstr &MI, MachineRegisterInfo &MRI,
1680 return eraseInstrs({&MI}, MRI, LocObserver);
1683 void llvm::salvageDebugInfo(const MachineRegisterInfo &MRI, MachineInstr &MI) {
1688 for (auto &MOUse : MRI.use_operands(Def.getReg())) {
1697 salvageDebugInfoForDbgValue(MRI, MI, DbgUsers);
1756 const MachineRegisterInfo &MRI) {
1757 LLT Ty = MRI.getType(ShiftAmount);
1764 getIConstantVRegValWithLookThrough(ShiftAmount, MRI);
1770 GBuildVector *BV = getOpcodeDef<GBuildVector>(ShiftAmount, MRI);
1777 getIConstantVRegValWithLookThrough(BV->getSourceReg(I), MRI);
1803 static bool canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
1806 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1822 !shiftAmountKnownInRange(RegDef->getOperand(2).getReg(), MRI);
1855 !shiftAmountKnownInRange(RegDef->getOperand(2).getReg(), MRI);
1860 getIConstantVRegValWithLookThrough(Insert->getIndexReg(), MRI);
1863 LLT VecTy = MRI.getType(Insert->getVectorReg());
1872 getIConstantVRegValWithLookThrough(Extract->getIndexReg(), MRI);
1875 LLT VecTy = MRI.getType(Extract->getVectorReg());
1906 const MachineRegisterInfo &MRI,
1912 MachineInstr *RegDef = MRI.getVRegDef(Reg);
1926 if (!::isGuaranteedNotToBeUndefOrPoison(BV->getSourceReg(I), MRI,
1935 if (!::isGuaranteedNotToBeUndefOrPoison(Phi->getIncomingValue(I), MRI,
1944 return ::isGuaranteedNotToBeUndefOrPoison(MO.getReg(), MRI, Depth + 1,
1947 return !::canCreateUndefOrPoison(Reg, MRI,
1954 bool llvm::canCreateUndefOrPoison(Register Reg, const MachineRegisterInfo &MRI,
1956 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
1960 bool canCreatePoison(Register Reg, const MachineRegisterInfo &MRI,
1962 return ::canCreateUndefOrPoison(Reg, MRI, ConsiderFlagsAndMetadata,
1967 const MachineRegisterInfo &MRI,
1969 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
1974 const MachineRegisterInfo &MRI,
1976 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
1981 const MachineRegisterInfo &MRI,
1983 return ::isGuaranteedNotToBeUndefOrPoison(Reg, MRI, Depth,
2001 llvm::GIConstant::getConstant(Register Const, const MachineRegisterInfo &MRI) {
2002 MachineInstr *Constant = getDefIgnoringCopies(Const, MRI);
2006 getIConstantVRegValWithLookThrough(Splat->getScalarReg(), MRI);
2018 getIConstantVRegValWithLookThrough(SrcReg, MRI);
2027 getIConstantVRegValWithLookThrough(Const, MRI);
2041 llvm::GFConstant::getConstant(Register Const, const MachineRegisterInfo &MRI) {
2042 MachineInstr *Constant = getDefIgnoringCopies(Const, MRI);
2046 getFConstantVRegValWithLookThrough(Splat->getScalarReg(), MRI);
2058 getFConstantVRegValWithLookThrough(SrcReg, MRI);
2067 getFConstantVRegValWithLookThrough(Const, MRI);