Lines Matching refs:MRI
62 : Builder(B), MRI(Builder.getMF().getRegInfo()), Observer(Observer), VT(VT), in CombinerHelper()
95 auto &MRI = *MIB.getMRI(); in buildLogBase2() local
96 LLT Ty = MRI.getType(V); in buildLogBase2()
181 void CombinerHelper::replaceRegWith(MachineRegisterInfo &MRI, Register FromReg, in replaceRegWith() argument
183 Observer.changingAllUsesOfReg(MRI, FromReg); in replaceRegWith()
185 if (MRI.constrainRegAttrs(ToReg, FromReg)) in replaceRegWith()
186 MRI.replaceRegWith(FromReg, ToReg); in replaceRegWith()
193 void CombinerHelper::replaceRegOpWith(MachineRegisterInfo &MRI, in replaceRegOpWith() argument
214 return RBI->getRegBank(Reg, MRI, *TRI); in getRegBank()
220 MRI.setRegBank(Reg, *RegBank); in setRegBank()
235 return canReplaceReg(DstReg, SrcReg, MRI); in matchCombineCopy()
240 replaceRegWith(MRI, DstReg, SrcReg); in applyCombineCopy()
250 if (!MRI.hasOneNonDBGUse(OrigOp)) in matchFreezeOfSingleMaybePoisonOperand()
253 MachineInstr *OrigDef = MRI.getUniqueVRegDef(OrigOp); in matchFreezeOfSingleMaybePoisonOperand()
265 if (canCreateUndefOrPoison(OrigOp, MRI, in matchFreezeOfSingleMaybePoisonOperand()
274 if (isGuaranteedNotToBeUndefOrPoison(Operand.getReg(), MRI)) in matchFreezeOfSingleMaybePoisonOperand()
298 LLT MaybePoisonOperandRegTy = MRI.getType(MaybePoisonOperandReg); in matchFreezeOfSingleMaybePoisonOperand()
307 MRI, *OrigDef->findRegisterUseOperand(MaybePoisonOperandReg, TRI), in matchFreezeOfSingleMaybePoisonOperand()
309 replaceRegWith(MRI, DstOp, OrigOp); in matchFreezeOfSingleMaybePoisonOperand()
326 MachineInstr *Def = MRI.getVRegDef(Reg); in matchCombineConcatVectors()
328 if (!MRI.hasOneNonDBGUse(Reg)) in matchCombineConcatVectors()
339 LLT OpType = MRI.getType(Reg); in matchCombineConcatVectors()
345 assert(MRI.getType(Undef->getOperand(0).getReg()) == in matchCombineConcatVectors()
361 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineConcatVectors()
363 {TargetOpcode::G_BUILD_VECTOR, {DstTy, MRI.getType(Ops[0])}})) { in matchCombineConcatVectors()
378 Register NewDstReg = MRI.cloneVirtualRegister(DstReg); in applyCombineConcatVectors()
390 replaceRegWith(MRI, DstReg, NewDstReg); in applyCombineConcatVectors()
402 LLT SrcVec1Type = MRI.getType(SrcVec1); in matchCombineShuffleToBuildVector()
403 LLT SrcVec2Type = MRI.getType(SrcVec2); in matchCombineShuffleToBuildVector()
412 LLT EltTy = MRI.getType(SrcVec1).getElementType(); in applyCombineShuffleToBuildVector()
413 int Width = MRI.getType(SrcVec1).getNumElements(); in applyCombineShuffleToBuildVector()
440 dyn_cast<GConcatVectors>(MRI.getVRegDef(MI.getOperand(1).getReg())); in matchCombineShuffleConcat()
442 dyn_cast<GConcatVectors>(MRI.getVRegDef(MI.getOperand(2).getReg())); in matchCombineShuffleConcat()
447 if (MRI.getType(ConcatMI1->getSourceReg(0)) != in matchCombineShuffleConcat()
448 MRI.getType(ConcatMI2->getSourceReg(0))) in matchCombineShuffleConcat()
451 LLT ConcatSrcTy = MRI.getType(ConcatMI1->getReg(1)); in matchCombineShuffleConcat()
452 LLT ShuffleSrcTy1 = MRI.getType(MI.getOperand(1).getReg()); in matchCombineShuffleConcat()
490 {MRI.getType(MI.getOperand(0).getReg()), ConcatSrcTy}})) in matchCombineShuffleConcat()
501 SrcTy = MRI.getType(Reg); in applyCombineShuffleConcat()
535 LLT DstType = MRI.getType(MI.getOperand(0).getReg()); in matchCombineShuffleVector()
537 LLT SrcType = MRI.getType(Src1); in matchCombineShuffleVector()
611 Register NewDstReg = MRI.cloneVirtualRegister(DstReg); in applyCombineShuffleVector()
618 replaceRegWith(MRI, DstReg, NewDstReg); in applyCombineShuffleVector()
636 LLT Src1Ty = MRI.getType(Src1); in applyShuffleToExtract()
647 else if (!MRI.getType(SrcReg).isVector()) in applyShuffleToExtract()
784 LLT LoadValueTy = MRI.getType(LoadReg); in matchCombineExtendingLoads()
811 for (auto &UseMI : MRI.use_nodbg_instructions(LoadReg)) { in matchCombineExtendingLoads()
823 LLT UseTy = MRI.getType(UseMI.getOperand(0).getReg()); in matchCombineExtendingLoads()
824 LLT SrcTy = MRI.getType(LoadMI->getPointerReg()); in matchCombineExtendingLoads()
830 MRI.getType(UseMI.getOperand(0).getReg()), in matchCombineExtendingLoads()
866 Register NewDstReg = MRI.cloneVirtualRegister(MI.getOperand(0).getReg()); in applyCombineExtendingLoads()
869 replaceRegOpWith(MRI, UseMO, NewDstReg); in applyCombineExtendingLoads()
879 llvm::make_pointer_range(MRI.use_operands(LoadValue.getReg()))); in applyCombineExtendingLoads()
890 const LLT UseDstTy = MRI.getType(UseDstReg); in applyCombineExtendingLoads()
902 replaceRegWith(MRI, UseDstReg, ChosenDstReg); in applyCombineExtendingLoads()
916 replaceRegOpWith(MRI, UseSrcMO, ChosenDstReg); in applyCombineExtendingLoads()
964 if (MRI.getType(Dst).isVector()) in matchCombineLoadWithAndMask()
968 getIConstantVRegValWithLookThrough(MI.getOperand(2).getReg(), MRI); in matchCombineLoadWithAndMask()
980 GAnyLoad *LoadMI = dyn_cast<GAnyLoad>(MRI.getVRegDef(SrcReg)); in matchCombineLoadWithAndMask()
981 if (!LoadMI || !MRI.hasOneNonDBGUse(LoadMI->getDstReg())) in matchCombineLoadWithAndMask()
985 LLT RegTy = MRI.getType(LoadReg); in matchCombineLoadWithAndMask()
1019 {TargetOpcode::G_ZEXTLOAD, {RegTy, MRI.getType(PtrReg)}, {MemDesc}})) in matchCombineLoadWithAndMask()
1066 if (MRI.getType(SrcReg).isVector()) in matchSextTruncSextLoad()
1070 if (mi_match(SrcReg, MRI, m_GTrunc(m_Reg(TruncSrc)))) in matchSextTruncSextLoad()
1076 if (auto *LoadMI = getOpcodeDef<GSExtLoad>(LoadUser, MRI)) { in matchSextTruncSextLoad()
1080 MRI.getType(TruncSrc).getSizeInBits() < LoadSizeBits.getValue()) in matchSextTruncSextLoad()
1099 LLT RegTy = MRI.getType(DstReg); in matchSextInRegOfLoad()
1106 auto *LoadDef = getOpcodeDef<GLoad>(SrcReg, MRI); in matchSextInRegOfLoad()
1107 if (!LoadDef || !MRI.hasOneNonDBGUse(SrcReg)) in matchSextInRegOfLoad()
1137 {MRI.getType(LoadDef->getDstReg()), in matchSextInRegOfLoad()
1138 MRI.getType(LoadDef->getPointerReg())}, in matchSextInRegOfLoad()
1152 GLoad *LoadDef = cast<GLoad>(MRI.getVRegDef(LoadReg)); in applySextInRegOfLoad()
1176 MachineRegisterInfo &MRI) { in canFoldInAddressingMode() argument
1179 auto *Addr = getOpcodeDef<GPtrAdd>(MI->getPointerReg(), MRI); in canFoldInAddressingMode()
1184 if (auto CstOff = getIConstantVRegVal(Addr->getOffsetReg(), MRI)) in canFoldInAddressingMode()
1213 LLT PtrTy = MRI.getType(LdSt.getPointerReg()); in isIndexedLoadStoreLegal()
1214 LLT Ty = MRI.getType(LdSt.getReg(0)); in isIndexedLoadStoreLegal()
1247 if (MRI.hasOneNonDBGUse(Ptr)) in findPostIndexCandidate()
1253 if (getOpcodeDef(TargetOpcode::G_FRAME_INDEX, Ptr, MRI)) in findPostIndexCandidate()
1256 MachineInstr *StoredValDef = getDefIgnoringCopies(LdSt.getReg(0), MRI); in findPostIndexCandidate()
1257 auto *PtrDef = MRI.getVRegDef(Ptr); in findPostIndexCandidate()
1260 for (auto &Use : MRI.use_nodbg_instructions(Ptr)) { in findPostIndexCandidate()
1267 if (!PtrAdd || MRI.use_nodbg_empty(PtrAdd->getReg(0))) in findPostIndexCandidate()
1278 /*IsPre*/ false, MRI)) in findPostIndexCandidate()
1282 MachineInstr *OffsetDef = MRI.getVRegDef(Offset); in findPostIndexCandidate()
1292 for (auto &BasePtrUse : MRI.use_nodbg_instructions(PtrAdd->getBaseReg())) { in findPostIndexCandidate()
1308 for (auto &BaseUseUse : MRI.use_nodbg_instructions(PtrAddDefReg)) { in findPostIndexCandidate()
1315 if (canFoldInAddressingMode(UseUseLdSt, TLI, MRI)) in findPostIndexCandidate()
1338 if (!mi_match(Addr, MRI, m_GPtrAdd(m_Reg(Base), m_Reg(Offset))) || in findPreIndexCandidate()
1339 MRI.hasOneNonDBGUse(Addr)) in findPreIndexCandidate()
1343 !TLI.isIndexingLegal(LdSt, Base, Offset, /*IsPre*/ true, MRI)) in findPreIndexCandidate()
1349 MachineInstr *BaseDef = getDefIgnoringCopies(Base, MRI); in findPreIndexCandidate()
1365 for (auto &AddrUse : MRI.use_nodbg_instructions(Addr)) in findPreIndexCandidate()
1372 for (auto &AddrUse : MRI.use_nodbg_instructions(Addr)) { in findPreIndexCandidate()
1379 if (!canFoldInAddressingMode(UseLdSt, TLI, MRI)) in findPreIndexCandidate()
1393 auto *LoadMI = getOpcodeDef<GLoad>(MI.getOperand(1).getReg(), MRI); in matchCombineExtractedVectorLoad()
1398 LLT VecEltTy = MRI.getType(Vector).getElementType(); in matchCombineExtractedVectorLoad()
1400 assert(MRI.getType(MI.getOperand(0).getReg()) == VecEltTy); in matchCombineExtractedVectorLoad()
1403 if (!MRI.hasOneNonDBGUse(Vector)) in matchCombineExtractedVectorLoad()
1439 if (auto CVal = getIConstantVRegVal(Vector, MRI)) { in matchCombineExtractedVectorLoad()
1454 LLT PtrTy = MRI.getType(VecPtr); in matchCombineExtractedVectorLoad()
1482 LoadMI->getPointerReg(), MRI.getType(LoadMI->getOperand(0).getReg()), in matchCombineExtractedVectorLoad()
1512 MachineInstr &AddrDef = *MRI.getUniqueVRegDef(MatchInfo.Addr); in applyCombineIndexedLoadStore()
1520 auto *OldCst = MRI.getVRegDef(MatchInfo.Offset); in applyCombineIndexedLoadStore()
1521 auto NewCst = Builder.buildConstant(MRI.getType(MatchInfo.Offset), in applyCombineIndexedLoadStore()
1579 if (!isLegalOrBeforeLegalizer({DivremOpcode, {MRI.getType(Src1)}})) in matchCombineDivRem()
1594 for (auto &UseMI : MRI.use_nodbg_instructions(Src1)) { in matchCombineDivRem()
1678 LLT Ty = MRI.getType(BrCond->getOperand(0).getReg()); in applyOptBrCondByInvertingCond()
1717 const MachineRegisterInfo &MRI, in constantFoldFpUnary() argument
1733 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in constantFoldFpUnary()
1763 APFloat Folded = constantFoldFpUnary(MI, MRI, Cst->getValue()); in applyCombineConstantFoldFpUnary()
1782 auto MaybeImmVal = getIConstantVRegValWithLookThrough(Imm1, MRI); in matchPtrAddImmedChain()
1786 MachineInstr *Add2Def = MRI.getVRegDef(Add2); in matchPtrAddImmedChain()
1792 auto MaybeImm2Val = getIConstantVRegValWithLookThrough(Imm2, MRI); in matchPtrAddImmedChain()
1802 for (auto &UseMI : MRI.use_nodbg_instructions(MI.getOperand(0).getReg())) { in matchPtrAddImmedChain()
1804 AccessTy = getTypeForLLT(MRI.getType(LdSt->getReg(0)), in matchPtrAddImmedChain()
1817 unsigned AS = MRI.getType(Add2).getAddressSpace(); in matchPtrAddImmedChain()
1835 LLT OffsetTy = MRI.getType(MI.getOperand(2).getReg()); in applyPtrAddImmedChain()
1861 auto MaybeImmVal = getIConstantVRegValWithLookThrough(Imm1, MRI); in matchShiftImmedChain()
1865 MachineInstr *Shl2Def = MRI.getUniqueVRegDef(Shl2); in matchShiftImmedChain()
1871 auto MaybeImm2Val = getIConstantVRegValWithLookThrough(Imm2, MRI); in matchShiftImmedChain()
1883 MatchInfo.Imm >= MRI.getType(Shl2).getScalarSizeInBits()) in matchShiftImmedChain()
1897 LLT Ty = MRI.getType(MI.getOperand(1).getReg()); in applyShiftImmedChain()
1913 LLT ImmTy = MRI.getType(MI.getOperand(2).getReg()); in applyShiftImmedChain()
1943 if (!MRI.hasOneNonDBGUse(LogicDest)) in matchShiftOfShiftedLogic()
1946 MachineInstr *LogicMI = MRI.getUniqueVRegDef(LogicDest); in matchShiftOfShiftedLogic()
1954 auto MaybeImmVal = getIConstantVRegValWithLookThrough(C1, MRI); in matchShiftOfShiftedLogic()
1963 !MRI.hasOneNonDBGUse(MI->getOperand(0).getReg())) in matchShiftOfShiftedLogic()
1968 getIConstantVRegValWithLookThrough(MI->getOperand(2).getReg(), MRI); in matchShiftOfShiftedLogic()
1978 MachineInstr *LogicMIOp1 = MRI.getUniqueVRegDef(LogicMIReg1); in matchShiftOfShiftedLogic()
1980 MachineInstr *LogicMIOp2 = MRI.getUniqueVRegDef(LogicMIReg2); in matchShiftOfShiftedLogic()
1995 if (MatchInfo.ValSum >= MRI.getType(LogicDest).getScalarSizeInBits()) in matchShiftOfShiftedLogic()
2010 LLT ShlType = MRI.getType(MI.getOperand(2).getReg()); in applyShiftOfShiftedLogic()
2011 LLT DestType = MRI.getType(MI.getOperand(0).getReg()); in applyShiftOfShiftedLogic()
2055 if (!mi_match(SrcReg, MRI, in matchCommuteShift()
2061 if (!mi_match(C1, MRI, m_ICstOrSplat(C1Val)) || in matchCommuteShift()
2062 !mi_match(ShiftReg, MRI, m_ICstOrSplat(C2Val))) in matchCommuteShift()
2065 auto *SrcDef = MRI.getVRegDef(SrcReg); in matchCommuteShift()
2068 LLT SrcTy = MRI.getType(SrcReg); in matchCommuteShift()
2081 getIConstantVRegValWithLookThrough(MI.getOperand(2).getReg(), MRI); in matchCombineMulToShl()
2093 LLT ShiftTy = MRI.getType(MI.getOperand(0).getReg()); in applyCombineMulToShl()
2107 LLT Ty = MRI.getType(Sub.getReg(0)); in matchCombineSubToAdd()
2115 APInt Imm = getIConstantFromReg(Sub.getRHSReg(), MRI); in matchCombineSubToAdd()
2140 if (!mi_match(LHS, MRI, m_GAnyExt(m_Reg(ExtSrc))) && in matchCombineShlOfExtend()
2141 !mi_match(LHS, MRI, m_GZExt(m_Reg(ExtSrc))) && in matchCombineShlOfExtend()
2142 !mi_match(LHS, MRI, m_GSExt(m_Reg(ExtSrc)))) in matchCombineShlOfExtend()
2146 MachineInstr *MIShiftAmt = MRI.getVRegDef(RHS); in matchCombineShlOfExtend()
2147 auto MaybeShiftAmtVal = isConstantOrConstantSplatVector(*MIShiftAmt, MRI); in matchCombineShlOfExtend()
2152 LLT SrcTy = MRI.getType(ExtSrc); in matchCombineShlOfExtend()
2167 unsigned SrcTySize = MRI.getType(ExtSrc).getScalarSizeInBits(); in matchCombineShlOfExtend()
2176 LLT ExtSrcTy = MRI.getType(ExtSrcReg); in applyCombineShlOfExtend()
2191 auto *Unmerge = getOpcodeDef<GUnmerge>(MergedValues[0], MRI); in matchCombineMergeUnmerge()
2204 const MachineRegisterInfo &MRI) { in peekThroughBitcast() argument
2205 while (mi_match(Reg, MRI, m_GBitcast(m_Reg(Reg)))) in peekThroughBitcast()
2216 Register SrcReg = peekThroughBitcast(Unmerge.getSourceReg(), MRI); in matchCombineUnmergeMergeToPlainValues()
2218 auto *SrcInstr = getOpcodeDef<GMergeLikeInstr>(SrcReg, MRI); in matchCombineUnmergeMergeToPlainValues()
2223 LLT SrcMergeTy = MRI.getType(SrcInstr->getSourceReg(0)); in matchCombineUnmergeMergeToPlainValues()
2224 LLT Dst0Ty = MRI.getType(Unmerge.getReg(0)); in matchCombineUnmergeMergeToPlainValues()
2243 LLT SrcTy = MRI.getType(Operands[0]); in applyCombineUnmergeMergeToPlainValues()
2244 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in applyCombineUnmergeMergeToPlainValues()
2252 const auto &DstCB = MRI.getRegClassOrRegBank(DstReg); in applyCombineUnmergeMergeToPlainValues()
2253 if (!DstCB.isNull() && DstCB != MRI.getRegClassOrRegBank(SrcReg)) { in applyCombineUnmergeMergeToPlainValues()
2254 SrcReg = Builder.buildCopy(MRI.getType(SrcReg), SrcReg).getReg(0); in applyCombineUnmergeMergeToPlainValues()
2255 MRI.setRegClassOrRegBank(SrcReg, DstCB); in applyCombineUnmergeMergeToPlainValues()
2259 replaceRegWith(MRI, DstReg, SrcReg); in applyCombineUnmergeMergeToPlainValues()
2270 MachineInstr *SrcInstr = MRI.getVRegDef(SrcReg); in matchCombineUnmergeConstant()
2280 LLT Dst0Ty = MRI.getType(MI.getOperand(0).getReg()); in matchCombineUnmergeConstant()
2318 return isa<GImplicitDef>(MRI.getVRegDef(SrcReg)); in matchCombineUnmergeUndef()
2325 if (MRI.getType(MI.getOperand(0).getReg()).isVector() || in matchCombineUnmergeWithDeadLanesToTrunc()
2326 MRI.getType(MI.getOperand(MI.getNumDefs()).getReg()).isVector()) in matchCombineUnmergeWithDeadLanesToTrunc()
2330 if (!MRI.use_nodbg_empty(MI.getOperand(Idx).getReg())) in matchCombineUnmergeWithDeadLanesToTrunc()
2348 LLT Dst0Ty = MRI.getType(Dst0Reg); in matchCombineUnmergeZExtToZExt()
2355 LLT SrcTy = MRI.getType(SrcReg); in matchCombineUnmergeZExtToZExt()
2360 if (!mi_match(SrcReg, MRI, m_GZExt(m_Reg(ZExtSrcReg)))) in matchCombineUnmergeZExtToZExt()
2366 LLT ZExtSrcTy = MRI.getType(ZExtSrcReg); in matchCombineUnmergeZExtToZExt()
2377 MRI.getVRegDef(MI.getOperand(MI.getNumDefs()).getReg()); in applyCombineUnmergeZExtToZExt()
2382 LLT Dst0Ty = MRI.getType(Dst0Reg); in applyCombineUnmergeZExtToZExt()
2383 LLT ZExtSrcTy = MRI.getType(ZExtSrcReg); in applyCombineUnmergeZExtToZExt()
2390 replaceRegWith(MRI, Dst0Reg, ZExtSrcReg); in applyCombineUnmergeZExtToZExt()
2397 replaceRegWith(MRI, MI.getOperand(Idx).getReg(), ZeroReg); in applyCombineUnmergeZExtToZExt()
2409 LLT Ty = MRI.getType(MI.getOperand(0).getReg()); in matchCombineShiftToUnmerge()
2419 getIConstantVRegValWithLookThrough(MI.getOperand(2).getReg(), MRI); in matchCombineShiftToUnmerge()
2431 LLT Ty = MRI.getType(SrcReg); in applyCombineShiftToUnmerge()
2514 LLT DstTy = MRI.getType(DstReg); in matchCombineI2PToP2I()
2516 return mi_match(SrcReg, MRI, in matchCombineI2PToP2I()
2541 LLT IntTy = MRI.getType(LHS); in matchCombineAddP2IToPtrAdd()
2547 if (mi_match(SrcReg, MRI, m_GPtrToInt(m_Reg(PtrReg.first)))) { in matchCombineAddP2IToPtrAdd()
2550 LLT PtrTy = MRI.getType(PtrReg.first); in matchCombineAddP2IToPtrAdd()
2572 LLT PtrTy = MRI.getType(LHS); in applyCombineAddP2IToPtrAdd()
2584 MachineRegisterInfo &MRI = Builder.getMF().getRegInfo(); in matchCombineConstPtrAddToI2P() local
2586 if (auto RHSCst = getIConstantVRegVal(RHS, MRI)) { in matchCombineConstPtrAddToI2P()
2588 if (mi_match(LHS, MRI, m_GIntToPtr(m_ICst(Cst)))) { in matchCombineConstPtrAddToI2P()
2589 auto DstTy = MRI.getType(PtrAdd.getReg(0)); in matchCombineConstPtrAddToI2P()
2614 Register OriginalSrcReg = getSrcRegIgnoringCopies(SrcReg, MRI); in matchCombineAnyExtTrunc()
2617 LLT DstTy = MRI.getType(DstReg); in matchCombineAnyExtTrunc()
2618 return mi_match(SrcReg, MRI, in matchCombineAnyExtTrunc()
2620 canReplaceReg(DstReg, Reg, MRI); in matchCombineAnyExtTrunc()
2628 LLT DstTy = MRI.getType(DstReg); in matchCombineZextTrunc()
2629 if (mi_match(SrcReg, MRI, in matchCombineZextTrunc()
2631 canReplaceReg(DstReg, Reg, MRI)) { in matchCombineZextTrunc()
2633 unsigned SrcSize = MRI.getType(SrcReg).getScalarSizeInBits(); in matchCombineZextTrunc()
2662 if (!MRI.hasOneNonDBGUse(SrcReg)) in matchCombineTruncOfShift()
2665 LLT SrcTy = MRI.getType(SrcReg); in matchCombineTruncOfShift()
2666 LLT DstTy = MRI.getType(DstReg); in matchCombineTruncOfShift()
2668 MachineInstr *SrcMI = getDefIgnoringCopies(SrcReg, MRI); in matchCombineTruncOfShift()
2691 for (auto &User : MRI.use_instructions(DstReg)) in matchCombineTruncOfShift()
2723 LLT DstTy = MRI.getType(Dst); in applyCombineTruncOfShift()
2735 replaceRegWith(MRI, Dst, NewShift); in applyCombineTruncOfShift()
2745 getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF, MO.getReg(), MRI); in matchAnyExplicitUseIsUndef()
2752 getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF, MO.getReg(), MRI); in matchAllExplicitUsesAreUndef()
2765 MRI); in matchUndefStore()
2771 MRI); in matchUndefSelectCmp()
2779 LLT VecTy = MRI.getType(MI.getOperand(1).getReg()); in matchInsertExtractVecEltOutOfBounds()
2785 auto Idx = getIConstantVRegVal(MI.getOperand(IdxIdx).getReg(), MRI); in matchInsertExtractVecEltOutOfBounds()
2795 isConstantOrConstantSplatVector(*MRI.getVRegDef(SelMI.getCondReg()), MRI); in matchConstantSelectCmp()
2808 auto InstAndDef1 = getDefSrcRegIgnoringCopies(MOP1.getReg(), MRI); in matchEqualDefs()
2811 auto InstAndDef2 = getDefSrcRegIgnoringCopies(MOP2.getReg(), MRI); in matchEqualDefs()
2888 if (Builder.getTII().produceSameValue(*I1, *I2, &MRI)) { in matchEqualDefs()
2905 auto *MI = MRI.getVRegDef(MOP.getReg()); in matchConstantOp()
2906 auto MaybeCst = isConstantOrConstantSplatVector(*MI, MRI); in matchConstantOp()
2916 if (!mi_match(MOP.getReg(), MRI, m_GFCstOrSplat(MaybeCst))) in matchConstantFPOp()
2927 assert(canReplaceReg(OldReg, Replacement, MRI) && "Cannot replace register?"); in replaceSingleDefInstWithOperand()
2928 replaceRegWith(MRI, OldReg, Replacement); in replaceSingleDefInstWithOperand()
2936 assert(canReplaceReg(OldReg, Replacement, MRI) && "Cannot replace register?"); in replaceSingleDefInstWithReg()
2937 replaceRegWith(MRI, OldReg, Replacement); in replaceSingleDefInstWithReg()
2944 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchConstantLargerBitWidth()
2947 auto VRegAndVal = getIConstantVRegValWithLookThrough(ConstReg, MRI); in matchConstantLargerBitWidth()
2961 LLT ConstTy = MRI.getType(ConstReg); in applyFunnelShiftConstantModulo()
2962 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in applyFunnelShiftConstantModulo()
2964 auto VRegAndVal = getIConstantVRegValWithLookThrough(ConstReg, MRI); in applyFunnelShiftConstantModulo()
2984 MRI); in matchSelectSameVal()
2990 MRI); in matchBinOpSameVal()
2997 MRI); in matchOperandIsZero()
3004 getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF, MO.getReg(), MRI); in matchOperandIsUndef()
3010 return isKnownToBeAPowerOfTwo(MO.getReg(), MRI, VT); in matchOperandIsKnownToBeAPowerOfTwo()
3057 if (!mi_match(MaybeSub, MRI, m_Neg(m_Reg(NewRHS)))) in matchSimplifyAddToSub()
3071 LLT DstTy = MRI.getType(DstReg); in matchCombineInsertVecElts()
3080 if (MRI.hasOneUse(DstReg) && MRI.use_instr_begin(DstReg)->getOpcode() == in matchCombineInsertVecElts()
3089 CurrInst->getOperand(0).getReg(), MRI, in matchCombineInsertVecElts()
3119 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in applyCombineInsertVecElts()
3157 if (!MRI.hasOneNonDBGUse(LHSReg) || !MRI.hasOneNonDBGUse(RHSReg)) in matchHoistLogicOpWithSameOpcodeHands()
3161 MachineInstr *LeftHandInst = getDefIgnoringCopies(LHSReg, MRI); in matchHoistLogicOpWithSameOpcodeHands()
3162 MachineInstr *RightHandInst = getDefIgnoringCopies(RHSReg, MRI); in matchHoistLogicOpWithSameOpcodeHands()
3178 LLT XTy = MRI.getType(X); in matchHoistLogicOpWithSameOpcodeHands()
3179 LLT YTy = MRI.getType(Y); in matchHoistLogicOpWithSameOpcodeHands()
3199 LLT DstTy = MRI.getType(Dst); in matchHoistLogicOpWithSameOpcodeHands()
3227 auto NewLogicDst = MRI.createGenericVirtualRegister(XTy); in matchHoistLogicOpWithSameOpcodeHands()
3266 if (!mi_match(MI.getOperand(0).getReg(), MRI, in matchAshrShlToSextInreg()
3273 {TargetOpcode::G_SEXT_INREG, {MRI.getType(Src)}})) in matchAshrShlToSextInreg()
3285 unsigned Size = MRI.getType(Src).getScalarSizeInBits(); in applyAshShlToSextInreg()
3297 LLT Ty = MRI.getType(Dst); in matchOverlappingAnd()
3303 Dst, MRI, in matchOverlappingAnd()
3313 replaceRegWith(MRI, Dst, Zero->getOperand(0).getReg()); in matchOverlappingAnd()
3358 if (canReplaceReg(AndDst, LHS, MRI) && in matchRedundantAnd()
3365 if (canReplaceReg(AndDst, RHS, MRI) && in matchRedundantAnd()
3400 if (canReplaceReg(OrDst, LHS, MRI) && in matchRedundantOr()
3407 if (canReplaceReg(OrDst, RHS, MRI) && in matchRedundantOr()
3420 unsigned TypeSize = MRI.getType(Src).getScalarSizeInBits(); in matchRedundantSExtInReg()
3451 LLT DstTy = MRI.getType(BuildMI->getReg(0)); in matchUseVectorTruncate()
3459 auto SrcMI = MRI.getVRegDef(BuildMI->getSourceReg(I)); in matchUseVectorTruncate()
3465 UnmergeMI = MRI.getVRegDef(SrcMI->getOperand(1).getReg()); in matchUseVectorTruncate()
3469 auto UnmergeSrcMI = MRI.getVRegDef(SrcMI->getOperand(1).getReg()); in matchUseVectorTruncate()
3482 auto SrcMI = MRI.getVRegDef(BuildMI->getSourceReg(I)); in matchUseVectorTruncate()
3491 LLT UnmergeSrcTy = MRI.getType(MatchInfo); in matchUseVectorTruncate()
3498 LLT UnmergeDstEltTy = MRI.getType(UnmergeDstReg); in matchUseVectorTruncate()
3522 LLT DstTy = MRI.getType(DstReg); in applyUseVectorTruncate()
3523 LLT UnmergeSrcTy = MRI.getType(MatchInfo); in applyUseVectorTruncate()
3547 LLT Ty = MRI.getType(MI.getOperand(0).getReg()); in matchNotCmp()
3552 if (!mi_match(MI.getOperand(0).getReg(), MRI, in matchNotCmp()
3556 if (!MRI.hasOneNonDBGUse(XorSrc)) in matchNotCmp()
3568 if (!MRI.hasOneNonDBGUse(Reg)) in matchNotCmp()
3570 MachineInstr *Def = MRI.getVRegDef(Reg); in matchNotCmp()
3605 MachineInstr *CstDef = MRI.getVRegDef(CstReg); in matchNotCmp()
3606 auto MaybeCst = getIConstantSplatSExtVal(*CstDef, MRI); in matchNotCmp()
3612 if (!mi_match(CstReg, MRI, m_ICst(Cst))) in matchNotCmp()
3624 MachineInstr *Def = MRI.getVRegDef(Reg); in applyNotCmp()
3649 replaceRegWith(MRI, MI.getOperand(0).getReg(), MI.getOperand(1).getReg()); in applyNotCmp()
3667 if (!mi_match(AndReg, MRI, m_GAnd(m_Reg(X), m_Reg(Y)))) { in matchXorOfAndWithSameReg()
3669 if (!mi_match(AndReg, MRI, m_GAnd(m_Reg(X), m_Reg(Y)))) in matchXorOfAndWithSameReg()
3674 if (!MRI.hasOneNonDBGUse(AndReg)) in matchXorOfAndWithSameReg()
3689 auto Not = Builder.buildNot(MRI.getType(X), X); in applyXorOfAndWithSameReg()
3700 LLT Ty = MRI.getType(DstReg); in matchPtrAddZero()
3707 auto ConstVal = getIConstantVRegVal(PtrAdd.getBaseReg(), MRI); in matchPtrAddZero()
3712 const MachineInstr *VecMI = MRI.getVRegDef(PtrAdd.getBaseReg()); in matchPtrAddZero()
3713 return isBuildVectorAllZeros(*VecMI, MRI); in matchPtrAddZero()
3727 LLT Ty = MRI.getType(DstReg); in applySimplifyURemByPow2()
3743 MachineInstr *Select = MRI.getVRegDef(LHS); in matchFoldBinOpIntoSelect()
3748 !MRI.hasOneNonDBGUse(LHS)) { in matchFoldBinOpIntoSelect()
3751 Select = MRI.getVRegDef(RHS); in matchFoldBinOpIntoSelect()
3753 !MRI.hasOneNonDBGUse(RHS)) in matchFoldBinOpIntoSelect()
3757 MachineInstr *SelectLHS = MRI.getVRegDef(Select->getOperand(2).getReg()); in matchFoldBinOpIntoSelect()
3758 MachineInstr *SelectRHS = MRI.getVRegDef(Select->getOperand(3).getReg()); in matchFoldBinOpIntoSelect()
3760 if (!isConstantOrConstantVector(*SelectLHS, MRI, in matchFoldBinOpIntoSelect()
3764 if (!isConstantOrConstantVector(*SelectRHS, MRI, in matchFoldBinOpIntoSelect()
3776 (isNullOrNullSplat(*SelectLHS, MRI) || in matchFoldBinOpIntoSelect()
3777 isAllOnesOrAllOnesSplat(*SelectLHS, MRI)) && in matchFoldBinOpIntoSelect()
3778 (isNullOrNullSplat(*SelectRHS, MRI) || in matchFoldBinOpIntoSelect()
3779 isAllOnesOrAllOnesSplat(*SelectRHS, MRI)); in matchFoldBinOpIntoSelect()
3783 return isConstantOrConstantVector(*MRI.getVRegDef(OtherOperandReg), MRI, in matchFoldBinOpIntoSelect()
3795 MachineInstr *Select = MRI.getVRegDef(MI.getOperand(SelectOperand).getReg()); in applyFoldBinOpIntoSelect()
3801 LLT Ty = MRI.getType(Dst); in applyFoldBinOpIntoSelect()
3858 MRI.getType(Root->getOperand(0).getReg()).getSizeInBytes() - 1; in findCandidatesForLoadOrCombine()
3867 if (!MRI.hasOneNonDBGUse(OrLHS) || !MRI.hasOneNonDBGUse(OrRHS)) in findCandidatesForLoadOrCombine()
3872 if (const MachineInstr *Or = getOpcodeDef(TargetOpcode::G_OR, OrLHS, MRI)) in findCandidatesForLoadOrCombine()
3876 if (const MachineInstr *Or = getOpcodeDef(TargetOpcode::G_OR, OrRHS, MRI)) in findCandidatesForLoadOrCombine()
3899 const MachineRegisterInfo &MRI) { in matchLoadAndBytePosition() argument
3900 assert(MRI.hasOneNonDBGUse(Reg) && in matchLoadAndBytePosition()
3904 if (!mi_match(Reg, MRI, in matchLoadAndBytePosition()
3914 auto *Load = getOpcodeDef<GZExtLoad>(MaybeLoad, MRI); in matchLoadAndBytePosition()
3963 auto LoadAndPos = matchLoadAndBytePosition(Reg, MemSizeInBits, MRI); in findLoadOffsetsForLoadOrCombine()
3988 if (!mi_match(Load->getOperand(1).getReg(), MRI, in findLoadOffsetsForLoadOrCombine()
4075 LLT Ty = MRI.getType(Dst); in matchLoadOrCombine()
4150 {TargetOpcode::G_LOAD, {Ty, MRI.getType(Ptr)}, {MMDesc}})) in matchLoadOrCombine()
4165 Register LoadDst = NeedsBSwap ? MRI.cloneVirtualRegister(Dst) : Dst; in matchLoadOrCombine()
4180 if (MRI.getType(DstReg).isVector()) in matchExtendThroughPhis()
4184 if (!MRI.hasOneNonDBGUse(DstReg)) in matchExtendThroughPhis()
4186 ExtMI = &*MRI.use_instr_nodbg_begin(DstReg); in matchExtendThroughPhis()
4198 if (Builder.getTII().isExtendLikelyToBeFolded(*ExtMI, MRI)) in matchExtendThroughPhis()
4206 auto *DefMI = getDefIgnoringCopies(PHI.getIncomingValue(I), MRI); in matchExtendThroughPhis()
4231 LLT ExtTy = MRI.getType(DstReg); in applyExtendThroughPhis()
4240 auto *SrcMI = MRI.getVRegDef(SrcReg); in applyExtendThroughPhis()
4265 auto *NewSrc = OldToNewSrcMap[MRI.getVRegDef(MO.getReg())]; in applyExtendThroughPhis()
4278 LLT SrcTy = MRI.getType(SrcVec); in matchExtractVecEltBuildVec()
4282 auto Cst = getIConstantVRegValWithLookThrough(MI.getOperand(2).getReg(), MRI); in matchExtractVecEltBuildVec()
4290 MachineInstr *SrcVecMI = MRI.getVRegDef(SrcVec); in matchExtractVecEltBuildVec()
4292 SrcVecMI = MRI.getVRegDef(SrcVecMI->getOperand(1).getReg()); in matchExtractVecEltBuildVec()
4300 if (!MRI.hasOneNonDBGUse(SrcVec) && in matchExtractVecEltBuildVec()
4312 LLT ScalarTy = MRI.getType(Reg); in applyExtractVecEltBuildVec()
4314 LLT DstTy = MRI.getType(DstReg); in applyExtractVecEltBuildVec()
4346 LLT DstTy = MRI.getType(DstReg); in matchExtractAllEltsFromBuildVector()
4350 for (MachineInstr &II : MRI.use_nodbg_instructions(DstReg)) { in matchExtractAllEltsFromBuildVector()
4353 auto Cst = getIConstantVRegVal(II.getOperand(2).getReg(), MRI); in matchExtractAllEltsFromBuildVector()
4373 replaceRegWith(MRI, ExtMI->getOperand(0).getReg(), Pair.first); in applyExtractAllEltsFromBuildVector()
4397 LLT Ty = MRI.getType(Dst); in matchOrShiftToFunnelShift()
4404 if (!mi_match(Dst, MRI, in matchOrShiftToFunnelShift()
4413 if (mi_match(ShlAmt, MRI, m_ICstOrSplat(CstShlAmt)) && in matchOrShiftToFunnelShift()
4414 mi_match(LShrAmt, MRI, m_ICstOrSplat(CstLShrAmt)) && in matchOrShiftToFunnelShift()
4419 } else if (mi_match(LShrAmt, MRI, in matchOrShiftToFunnelShift()
4425 } else if (mi_match(ShlAmt, MRI, in matchOrShiftToFunnelShift()
4435 LLT AmtTy = MRI.getType(Amt); in matchOrShiftToFunnelShift()
4455 return isLegalOrBeforeLegalizer({RotateOpc, {MRI.getType(X), MRI.getType(Y)}}); in matchFunnelShiftToRotate()
4474 MRI.getType(MI.getOperand(0).getReg()).getScalarSizeInBits(); in matchRotateOutOfRange()
4482 return matchUnaryPredicate(MRI, AmtReg, MatchOutOfRange) && OutOfRange; in matchRotateOutOfRange()
4489 MRI.getType(MI.getOperand(0).getReg()).getScalarSizeInBits(); in applyRotateOutOfRange()
4491 LLT AmtTy = MRI.getType(Amt); in applyRotateOutOfRange()
4537 MRI.getType(MI.getOperand(0).getReg()).isVector(), in matchICmpToTrueFalseKnownBits()
4562 LLT DstTy = MRI.getType(Dst); in matchICmpToLHSKnownBits()
4567 if (!mi_match(MI.getOperand(3).getReg(), MRI, m_SpecificICst(OneOrZero))) in matchICmpToLHSKnownBits()
4574 LLT LHSTy = MRI.getType(LHS); in matchICmpToLHSKnownBits()
4594 LLT Ty = MRI.getType(MI.getOperand(0).getReg()); in matchAndOrDisjointMask()
4602 if (!mi_match(MI, MRI, in matchAndOrDisjointMask()
4629 LLT Ty = MRI.getType(Src); in matchBitfieldExtractFromSExtInReg()
4637 Src, MRI, in matchBitfieldExtractFromSExtInReg()
4657 LLT Ty = MRI.getType(Dst); in matchBitfieldExtractFromAnd()
4667 if (!mi_match(And->getReg(0), MRI, in matchBitfieldExtractFromAnd()
4703 LLT Ty = MRI.getType(Dst); in matchBitfieldExtractFromShr()
4714 if (!mi_match(Dst, MRI, in matchBitfieldExtractFromShr()
4747 LLT Ty = MRI.getType(Dst); in matchBitfieldExtractFromShrAnd()
4756 if (!mi_match(Dst, MRI, in matchBitfieldExtractFromShrAnd()
4803 auto *Src1Def = getOpcodeDef<GPtrAdd>(Src1Reg, MRI); in reassociationCanBreakAddressingModePattern()
4809 if (MRI.hasOneNonDBGUse(Src1Reg)) in reassociationCanBreakAddressingModePattern()
4812 auto C1 = getIConstantVRegVal(Src1Def->getOffsetReg(), MRI); in reassociationCanBreakAddressingModePattern()
4815 auto C2 = getIConstantVRegVal(Src2Reg, MRI); in reassociationCanBreakAddressingModePattern()
4823 for (auto &UseMI : MRI.use_nodbg_instructions(PtrAdd.getReg(0))) { in reassociationCanBreakAddressingModePattern()
4831 if (!MRI.hasOneNonDBGUse(DefReg)) in reassociationCanBreakAddressingModePattern()
4833 ConvUseMI = &*MRI.use_instr_nodbg_begin(DefReg); in reassociationCanBreakAddressingModePattern()
4845 unsigned AS = MRI.getType(LdStMI->getPointerReg()).getAddressSpace(); in reassociationCanBreakAddressingModePattern()
4870 auto C2 = getIConstantVRegVal(RHS->getOperand(2).getReg(), MRI); in matchReassocConstantInnerRHS()
4875 LLT PtrTy = MRI.getType(MI.getOperand(0).getReg()); in matchReassocConstantInnerRHS()
4895 if (!mi_match(MI.getBaseReg(), MRI, in matchReassocConstantInnerLHS()
4907 auto NewCst = B.buildConstant(MRI.getType(RHSReg), LHSCstOff->Value); in matchReassocConstantInnerLHS()
4929 auto C1 = getIConstantVRegVal(LHSSrc2, MRI); in matchReassocFoldConstantsInSubTree()
4932 auto C2 = getIConstantVRegVal(Src2Reg, MRI); in matchReassocFoldConstantsInSubTree()
4937 auto NewCst = B.buildConstant(MRI.getType(Src2Reg), *C1 + *C2); in matchReassocFoldConstantsInSubTree()
4961 MachineInstr *LHS = MRI.getVRegDef(PtrAdd.getBaseReg()); in matchReassocPtrAdd()
4962 MachineInstr *RHS = MRI.getVRegDef(PtrAdd.getOffsetReg()); in matchReassocPtrAdd()
4981 LLT OpRHSTy = MRI.getType(OpRHS); in tryReassocBinOp()
4982 MachineInstr *OpLHSDef = MRI.getVRegDef(OpLHS); in tryReassocBinOp()
4987 MachineInstr *OpRHSDef = MRI.getVRegDef(OpRHS); in tryReassocBinOp()
4995 if (isConstantOrConstantSplatVector(*MRI.getVRegDef(OpLHSRHS), MRI) && in tryReassocBinOp()
4996 !isConstantOrConstantSplatVector(*MRI.getVRegDef(OpLHSLHS), MRI)) { in tryReassocBinOp()
4997 if (isConstantOrConstantSplatVector(*OpRHSDef, MRI)) { in tryReassocBinOp()
5005 if (getTargetLowering().isReassocProfitable(MRI, OpLHS, OpRHS)) { in tryReassocBinOp()
5037 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchConstantFoldCastOp()
5040 if (auto MaybeCst = ConstantFoldCastOp(MI.getOpcode(), DstTy, SrcOp, MRI)) { in matchConstantFoldCastOp()
5052 auto MaybeCst = ConstantFoldBinOp(MI.getOpcode(), Op1, Op2, MRI); in matchConstantFoldBinOp()
5063 auto MaybeCst = ConstantFoldFPBinOp(MI.getOpcode(), Op1, Op2, MRI); in matchConstantFoldFPBinOp()
5077 const ConstantFP *Op3Cst = getConstantFPVRegVal(Op3, MRI); in matchConstantFoldFMA()
5081 const ConstantFP *Op2Cst = getConstantFPVRegVal(Op2, MRI); in matchConstantFoldFMA()
5085 const ConstantFP *Op1Cst = getConstantFPVRegVal(Op1, MRI); in matchConstantFoldFMA()
5119 LLT WideTy = MRI.getType(Dst); in matchNarrowBinopFeedingAnd()
5123 if (!WideTy.isScalar() || !MRI.hasOneNonDBGUse(AndLHS)) in matchNarrowBinopFeedingAnd()
5132 MachineInstr *LHSInst = getDefIgnoringCopies(AndLHS, MRI); in matchNarrowBinopFeedingAnd()
5149 auto Cst = getIConstantVRegValWithLookThrough(AndRHS, MRI); in matchNarrowBinopFeedingAnd()
5192 if (!mi_match(MI.getOperand(3).getReg(), MRI, m_SpecificICstOrSplat(2))) in matchMulOBy2()
5211 if (!mi_match(MI.getOperand(3).getReg(), MRI, m_SpecificICstOrSplat(0))) in matchMulOBy0()
5215 if (!isConstantLegalOrBeforeLegalizer(MRI.getType(Dst)) || in matchMulOBy0()
5216 !isConstantLegalOrBeforeLegalizer(MRI.getType(Carry))) in matchMulOBy0()
5233 if (!mi_match(MI.getOperand(4).getReg(), MRI, m_SpecificICstOrSplat(0))) in matchAddEToAddO()
5266 if (mi_match(Dst, MRI, m_GSub(m_GAdd(m_Reg(X), m_Reg(Y)), m_Reg(Z)))) { in matchSubAddSameReg()
5269 if (Y == Z || (mi_match(Y, MRI, m_ICstOrSplat(CstY)) && in matchSubAddSameReg()
5270 mi_match(Z, MRI, m_SpecificICstOrSplat(CstY)))) in matchSubAddSameReg()
5272 else if (X == Z || (mi_match(X, MRI, m_ICstOrSplat(CstX)) && in matchSubAddSameReg()
5273 mi_match(Z, MRI, m_SpecificICstOrSplat(CstX)))) in matchSubAddSameReg()
5283 if (mi_match(Dst, MRI, m_GSub(m_Reg(X), m_GAdd(m_Reg(Y), m_Reg(Z))))) { in matchSubAddSameReg()
5286 if (X == Z || (mi_match(X, MRI, m_ICstOrSplat(CstX)) && in matchSubAddSameReg()
5287 mi_match(Z, MRI, m_SpecificICstOrSplat(CstX)))) in matchSubAddSameReg()
5289 else if (X == Y || (mi_match(X, MRI, m_ICstOrSplat(CstX)) && in matchSubAddSameReg()
5290 mi_match(Y, MRI, m_SpecificICstOrSplat(CstX)))) in matchSubAddSameReg()
5294 auto Zero = B.buildConstant(MRI.getType(Dst), 0); in matchSubAddSameReg()
5310 LLT Ty = MRI.getType(Dst); in buildUDivorURemUsingMul()
5320 auto *RHSDefInstr = cast<GenericMachineInstr>(getDefIgnoringCopies(RHS, MRI)); in buildUDivorURemUsingMul()
5321 bool IsSplat = getIConstantSplatVal(*RHSDefInstr, MRI).has_value(); in buildUDivorURemUsingMul()
5348 if (!matchUnaryPredicate(MRI, RHS, BuildExactUDIVPattern)) in buildUDivorURemUsingMul()
5419 bool Matched = matchUnaryPredicate(MRI, RHS, BuildUDIVPattern); in buildUDivorURemUsingMul()
5424 auto *RHSDef = getOpcodeDef<GBuildVector>(RHS, MRI); in buildUDivorURemUsingMul()
5431 assert(MRI.getType(RHS).isScalar() && in buildUDivorURemUsingMul()
5476 LLT DstTy = MRI.getType(Dst); in matchUDivorURemByConst()
5493 MRI, RHS, [](const Constant *C) { return C && !C->isNullValue(); }); in matchUDivorURemByConst()
5496 auto *RHSDef = MRI.getVRegDef(RHS); in matchUDivorURemByConst()
5497 if (!isConstantOrConstantVector(*RHSDef, MRI)) in matchUDivorURemByConst()
5517 MRI, RHS, [](const Constant *C) { return C && !C->isNullValue(); }); in matchUDivorURemByConst()
5529 LLT DstTy = MRI.getType(Dst); in matchSDivByConst()
5548 MRI, RHS, [](const Constant *C) { return C && !C->isNullValue(); }); in matchSDivByConst()
5551 auto *RHSDef = MRI.getVRegDef(RHS); in matchSDivByConst()
5552 if (!isConstantOrConstantVector(*RHSDef, MRI)) in matchSDivByConst()
5565 MRI, RHS, [](const Constant *C) { return C && !C->isNullValue(); }); in matchSDivByConst()
5579 LLT Ty = MRI.getType(Dst); in buildSDivUsingMul()
5589 auto *RHSDefInstr = cast<GenericMachineInstr>(getDefIgnoringCopies(RHS, MRI)); in buildSDivUsingMul()
5590 bool IsSplat = getIConstantSplatVal(*RHSDefInstr, MRI).has_value(); in buildSDivUsingMul()
5618 bool Matched = matchUnaryPredicate(MRI, RHS, BuildExactSDIVPattern); in buildSDivUsingMul()
5674 bool Matched = matchUnaryPredicate(MRI, RHS, BuildSDIVPattern); in buildSDivUsingMul()
5679 auto *RHSDef = getOpcodeDef<GBuildVector>(RHS, MRI); in buildSDivUsingMul()
5686 assert(MRI.getType(RHS).isScalar() && in buildSDivUsingMul()
5722 return matchUnaryPredicate(MRI, RHS, MatchPow2, /*AllowUndefs=*/false); in matchDivByPow2()
5731 LLT Ty = MRI.getType(Dst); in applySDivByPow2()
5790 LLT Ty = MRI.getType(Dst); in applyUDivByPow2()
5802 LLT Ty = MRI.getType(Dst); in matchUMulHToLShr()
5803 LLT RHSTy = MRI.getType(RHS); in matchUMulHToLShr()
5810 if (!matchUnaryPredicate(MRI, RHS, MatchPow2ExceptOne, false)) in matchUMulHToLShr()
5822 LLT Ty = MRI.getType(Dst); in applyUMulHToLShr()
5844 LLT Type = MRI.getType(Dst); in matchRedundantNegOperands()
5849 if (mi_match(Dst, MRI, m_GFAdd(m_Reg(X), m_GFNeg(m_Reg(Y)))) && in matchRedundantNegOperands()
5854 else if (mi_match(Dst, MRI, m_GFSub(m_Reg(X), m_GFNeg(m_Reg(Y)))) && in matchRedundantNegOperands()
5864 mi_match(X, MRI, m_GFNeg(m_Reg(X))) && in matchRedundantNegOperands()
5865 mi_match(Y, MRI, m_GFNeg(m_Reg(Y)))) { in matchRedundantNegOperands()
5886 LLT Ty = MRI.getType(MI.getOperand(0).getReg()); in matchFsubToFneg()
5889 ? getFConstantSplat(LHS, MRI, /* allowUndef */ true) in matchFsubToFneg()
5890 : getFConstantVRegValWithLookThrough(LHS, MRI); in matchFsubToFneg()
5909 Dst, Builder.buildFCanonicalize(MRI.getType(Dst), MatchInfo).getReg(0)); in applyFsubToFneg()
5922 const MachineRegisterInfo &MRI) { in hasMoreUses() argument
5923 return std::distance(MRI.use_instr_nodbg_begin(MI0.getOperand(0).getReg()), in hasMoreUses()
5924 MRI.use_instr_nodbg_end()) > in hasMoreUses()
5925 std::distance(MRI.use_instr_nodbg_begin(MI1.getOperand(0).getReg()), in hasMoreUses()
5926 MRI.use_instr_nodbg_end()); in hasMoreUses()
5937 LLT DstType = MRI.getType(MI.getOperand(0).getReg()); in canCombineFMadOrFMA()
5973 DefinitionAndSourceRegister LHS = {MRI.getVRegDef(Op1), Op1}; in matchCombineFAddFMulToFMadOrFMA()
5974 DefinitionAndSourceRegister RHS = {MRI.getVRegDef(Op2), Op2}; in matchCombineFAddFMulToFMadOrFMA()
5982 if (hasMoreUses(*LHS.MI, *RHS.MI, MRI)) in matchCombineFAddFMulToFMadOrFMA()
5988 (Aggressive || MRI.hasOneNonDBGUse(LHS.Reg))) { in matchCombineFAddFMulToFMadOrFMA()
5999 (Aggressive || MRI.hasOneNonDBGUse(RHS.Reg))) { in matchCombineFAddFMulToFMadOrFMA()
6023 DefinitionAndSourceRegister LHS = {MRI.getVRegDef(Op1), Op1}; in matchCombineFAddFpExtFMulToFMadOrFMA()
6024 DefinitionAndSourceRegister RHS = {MRI.getVRegDef(Op2), Op2}; in matchCombineFAddFpExtFMulToFMadOrFMA()
6025 LLT DstType = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFAddFpExtFMulToFMadOrFMA()
6034 if (hasMoreUses(*LHS.MI, *RHS.MI, MRI)) in matchCombineFAddFpExtFMulToFMadOrFMA()
6040 if (mi_match(LHS.Reg, MRI, m_GFPExt(m_MInstr(FpExtSrc))) && in matchCombineFAddFpExtFMulToFMadOrFMA()
6043 MRI.getType(FpExtSrc->getOperand(1).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMA()
6055 if (mi_match(RHS.Reg, MRI, m_GFPExt(m_MInstr(FpExtSrc))) && in matchCombineFAddFpExtFMulToFMadOrFMA()
6058 MRI.getType(FpExtSrc->getOperand(1).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMA()
6082 DefinitionAndSourceRegister LHS = {MRI.getVRegDef(Op1), Op1}; in matchCombineFAddFMAFMulToFMadOrFMA()
6083 DefinitionAndSourceRegister RHS = {MRI.getVRegDef(Op2), Op2}; in matchCombineFAddFMAFMulToFMadOrFMA()
6084 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFAddFMAFMulToFMadOrFMA()
6093 if (hasMoreUses(*LHS.MI, *RHS.MI, MRI)) in matchCombineFAddFMAFMulToFMadOrFMA()
6101 (MRI.getVRegDef(LHS.MI->getOperand(3).getReg())->getOpcode() == in matchCombineFAddFMAFMulToFMadOrFMA()
6103 MRI.hasOneNonDBGUse(LHS.MI->getOperand(0).getReg()) && in matchCombineFAddFMAFMulToFMadOrFMA()
6104 MRI.hasOneNonDBGUse(LHS.MI->getOperand(3).getReg())) { in matchCombineFAddFMAFMulToFMadOrFMA()
6110 (MRI.getVRegDef(RHS.MI->getOperand(3).getReg())->getOpcode() == in matchCombineFAddFMAFMulToFMadOrFMA()
6112 MRI.hasOneNonDBGUse(RHS.MI->getOperand(0).getReg()) && in matchCombineFAddFMAFMulToFMadOrFMA()
6113 MRI.hasOneNonDBGUse(RHS.MI->getOperand(3).getReg())) { in matchCombineFAddFMAFMulToFMadOrFMA()
6119 MachineInstr *FMulMI = MRI.getVRegDef(FMA->getOperand(3).getReg()); in matchCombineFAddFMAFMulToFMadOrFMA()
6126 Register InnerFMA = MRI.createGenericVirtualRegister(DstTy); in matchCombineFAddFMAFMulToFMadOrFMA()
6150 LLT DstType = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6153 DefinitionAndSourceRegister LHS = {MRI.getVRegDef(Op1), Op1}; in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6154 DefinitionAndSourceRegister RHS = {MRI.getVRegDef(Op2), Op2}; in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6163 if (hasMoreUses(*LHS.MI, *RHS.MI, MRI)) in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6183 mi_match(LHS.MI->getOperand(3).getReg(), MRI, in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6187 MRI.getType(FMulMI->getOperand(0).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6202 if (mi_match(LHS.Reg, MRI, m_GFPExt(m_MInstr(FMAMI))) && in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6204 MachineInstr *FMulMI = MRI.getVRegDef(FMAMI->getOperand(3).getReg()); in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6207 MRI.getType(FMAMI->getOperand(0).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6224 mi_match(RHS.MI->getOperand(3).getReg(), MRI, in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6228 MRI.getType(FMulMI->getOperand(0).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6243 if (mi_match(RHS.Reg, MRI, m_GFPExt(m_MInstr(FMAMI))) && in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6245 MachineInstr *FMulMI = MRI.getVRegDef(FMAMI->getOperand(3).getReg()); in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6248 MRI.getType(FMAMI->getOperand(0).getReg()))) { in matchCombineFAddFpExtFMulToFMadOrFMAAggressive()
6275 DefinitionAndSourceRegister LHS = {MRI.getVRegDef(Op1), Op1}; in matchCombineFSubFMulToFMadOrFMA()
6276 DefinitionAndSourceRegister RHS = {MRI.getVRegDef(Op2), Op2}; in matchCombineFSubFMulToFMadOrFMA()
6277 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFSubFMulToFMadOrFMA()
6284 hasMoreUses(*LHS.MI, *RHS.MI, MRI)) in matchCombineFSubFMulToFMadOrFMA()
6293 (Aggressive || MRI.hasOneNonDBGUse(LHS.Reg)))) { in matchCombineFSubFMulToFMadOrFMA()
6304 (Aggressive || MRI.hasOneNonDBGUse(RHS.Reg)))) { in matchCombineFSubFMulToFMadOrFMA()
6328 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFSubFNegFMulToFMadOrFMA()
6335 if (mi_match(LHSReg, MRI, m_GFNeg(m_MInstr(FMulMI))) && in matchCombineFSubFNegFMulToFMadOrFMA()
6336 (Aggressive || (MRI.hasOneNonDBGUse(LHSReg) && in matchCombineFSubFNegFMulToFMadOrFMA()
6337 MRI.hasOneNonDBGUse(FMulMI->getOperand(0).getReg()))) && in matchCombineFSubFNegFMulToFMadOrFMA()
6350 if (mi_match(RHSReg, MRI, m_GFNeg(m_MInstr(FMulMI))) && in matchCombineFSubFNegFMulToFMadOrFMA()
6351 (Aggressive || (MRI.hasOneNonDBGUse(RHSReg) && in matchCombineFSubFNegFMulToFMadOrFMA()
6352 MRI.hasOneNonDBGUse(FMulMI->getOperand(0).getReg()))) && in matchCombineFSubFNegFMulToFMadOrFMA()
6376 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFSubFpExtFMulToFMadOrFMA()
6383 if (mi_match(LHSReg, MRI, m_GFPExt(m_MInstr(FMulMI))) && in matchCombineFSubFpExtFMulToFMadOrFMA()
6385 (Aggressive || MRI.hasOneNonDBGUse(LHSReg))) { in matchCombineFSubFpExtFMulToFMadOrFMA()
6399 if (mi_match(RHSReg, MRI, m_GFPExt(m_MInstr(FMulMI))) && in matchCombineFSubFpExtFMulToFMadOrFMA()
6401 (Aggressive || MRI.hasOneNonDBGUse(RHSReg))) { in matchCombineFSubFpExtFMulToFMadOrFMA()
6427 LLT DstTy = MRI.getType(MI.getOperand(0).getReg()); in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6446 if ((mi_match(LHSReg, MRI, m_GFPExt(m_GFNeg(m_MInstr(FMulMI)))) || in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6447 mi_match(LHSReg, MRI, m_GFNeg(m_GFPExt(m_MInstr(FMulMI))))) && in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6450 MRI.getType(FMulMI->getOperand(0).getReg()))) { in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6452 Register FMAReg = MRI.createGenericVirtualRegister(DstTy); in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6462 if ((mi_match(RHSReg, MRI, m_GFPExt(m_GFNeg(m_MInstr(FMulMI)))) || in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6463 mi_match(RHSReg, MRI, m_GFNeg(m_GFPExt(m_MInstr(FMulMI))))) && in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6466 MRI.getType(FMulMI->getOperand(0).getReg()))) { in matchCombineFSubFpExtFNegFMulToFMadOrFMA()
6495 const ConstantFP *MaybeCst = getConstantFPVRegVal(MaybeNaNReg, MRI); in matchCombineFMinMaxNaN()
6515 return mi_match(MaybeSub, MRI, m_GSub(m_Reg(Src), m_Reg(Reg))) && in matchAddSubSameReg()
6539 LLT DstVecTy = MRI.getType(MI.getOperand(0).getReg()); in matchBuildVectorIdentityFold()
6545 MI, MRI, in matchBuildVectorIdentityFold()
6548 return MRI.getType(MatchInfo) == DstVecTy; in matchBuildVectorIdentityFold()
6555 MI, MRI, in matchBuildVectorIdentityFold()
6560 return MRI.getType(MatchInfo) == DstVecTy; in matchBuildVectorIdentityFold()
6571 if (!mi_match(MI.getOperand(1).getReg(), MRI, in matchTruncBuildVectorFold()
6575 return MRI.getType(MatchInfo) == MRI.getType(MI.getOperand(0).getReg()); in matchTruncBuildVectorFold()
6583 if (!mi_match(MI.getOperand(1).getReg(), MRI, in matchTruncLshrBuildVectorFold()
6588 LLT MatchTy = MRI.getType(MatchInfo); in matchTruncLshrBuildVectorFold()
6590 MatchTy == MRI.getType(MI.getOperand(0).getReg()); in matchTruncLshrBuildVectorFold()
6635 bool LHSSafe = isKnownNeverNaN(LHS, MRI); in computeRetValAgainstNaN()
6636 bool RHSSafe = isKnownNeverNaN(RHS, MRI); in computeRetValAgainstNaN()
6659 LLT DstTy = MRI.getType(Dst); in matchFPSelectToMinMax()
6667 if (!mi_match(Cond, MRI, in matchFPSelectToMinMax()
6696 auto KnownNonZeroSide = getFConstantVRegValWithLookThrough(CmpLHS, MRI); in matchFPSelectToMinMax()
6698 KnownNonZeroSide = getFConstantVRegValWithLookThrough(CmpRHS, MRI); in matchFPSelectToMinMax()
6716 if (mi_match(Cond, MRI, m_OneNonDBGUse(m_GTrunc(m_Reg(MaybeTrunc))))) in matchSimplifySelectToMinMax()
6737 Dst, MRI, in matchRedundantBinOpInEquality()
6742 if (!mi_match(Dst, MRI, in matchRedundantBinOpInEquality()
6750 auto Zero = B.buildConstant(MRI.getType(Y), 0); in matchRedundantBinOpInEquality()
6796 LLT ResTy = MRI.getType(MI.getOperand(0).getReg()); in matchShiftsTooBig()
6809 return matchUnaryPredicate(MRI, ShiftReg, IsShiftTooBig); in matchShiftsTooBig()
6828 if (!getIConstantVRegVal(LHS, MRI)) { in matchCommuteConstantToRHS()
6832 if (MRI.getVRegDef(LHS)->getOpcode() != in matchCommuteConstantToRHS()
6837 return MRI.getVRegDef(RHS)->getOpcode() != in matchCommuteConstantToRHS()
6839 !getIConstantVRegVal(RHS, MRI); in matchCommuteConstantToRHS()
6846 if (!mi_match(LHS, MRI, m_GFCstOrSplat(ValAndVReg))) in matchCommuteFPConstantToRHS()
6848 return !mi_match(RHS, MRI, m_GFCstOrSplat(ValAndVReg)); in matchCommuteFPConstantToRHS()
6874 LLT SrcTy = MRI.getType(Src); in isOneOrOneSplat()
6878 if (AllowUndefs && getOpcodeDef<GImplicitDef>(Src, MRI) != nullptr) in isOneOrOneSplat()
6880 auto IConstant = getIConstantVRegValWithLookThrough(Src, MRI); in isOneOrOneSplat()
6887 LLT SrcTy = MRI.getType(Src); in isZeroOrZeroSplat()
6891 if (AllowUndefs && getOpcodeDef<GImplicitDef>(Src, MRI) != nullptr) in isZeroOrZeroSplat()
6893 auto IConstant = getIConstantVRegValWithLookThrough(Src, MRI); in isZeroOrZeroSplat()
6903 GBuildVector *BuildVector = getOpcodeDef<GBuildVector>(Src, MRI); in isConstantSplatVector()
6910 getOpcodeDef<GImplicitDef>(BuildVector->getSourceReg(I), MRI); in isConstantSplatVector()
6916 getIConstantVRegValWithLookThrough(BuildVector->getSourceReg(I), MRI); in isConstantSplatVector()
6928 auto IConstant = getIConstantVRegValWithLookThrough(Src, MRI); in getConstantOrConstantSplatVector()
6932 GBuildVector *BuildVector = getOpcodeDef<GBuildVector>(Src, MRI); in getConstantOrConstantSplatVector()
6940 getIConstantVRegValWithLookThrough(BuildVector->getSourceReg(I), MRI); in getConstantOrConstantSplatVector()
6953 auto IConstant = getIConstantVRegValWithLookThrough(Src, MRI); in isConstantOrConstantVectorI()
6957 GBuildVector *BuildVector = getOpcodeDef<GBuildVector>(Src, MRI); in isConstantOrConstantVectorI()
6964 getIConstantVRegValWithLookThrough(BuildVector->getSourceReg(I), MRI); in isConstantOrConstantVectorI()
6979 LLT CondTy = MRI.getType(Select->getCondReg()); in tryFoldSelectOfConstants()
6980 LLT TrueTy = MRI.getType(Select->getTrueReg()); in tryFoldSelectOfConstants()
6991 getIConstantVRegValWithLookThrough(True, MRI); in tryFoldSelectOfConstants()
6993 getIConstantVRegValWithLookThrough(False, MRI); in tryFoldSelectOfConstants()
7023 Register Inner = MRI.createGenericVirtualRegister(CondTy); in tryFoldSelectOfConstants()
7034 Register Inner = MRI.createGenericVirtualRegister(CondTy); in tryFoldSelectOfConstants()
7045 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7056 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7067 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7081 Register Not = MRI.createGenericVirtualRegister(CondTy); in tryFoldSelectOfConstants()
7083 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7097 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7108 Register Not = MRI.createGenericVirtualRegister(CondTy); in tryFoldSelectOfConstants()
7110 Register Inner = MRI.createGenericVirtualRegister(TrueTy); in tryFoldSelectOfConstants()
7128 LLT CondTy = MRI.getType(Select->getCondReg()); in tryFoldBoolSelectToLogic()
7129 LLT TrueTy = MRI.getType(Select->getTrueReg()); in tryFoldBoolSelectToLogic()
7146 Register Ext = MRI.createGenericVirtualRegister(TrueTy); in tryFoldBoolSelectToLogic()
7159 Register Ext = MRI.createGenericVirtualRegister(TrueTy); in tryFoldBoolSelectToLogic()
7172 Register Inner = MRI.createGenericVirtualRegister(CondTy); in tryFoldBoolSelectToLogic()
7175 Register Ext = MRI.createGenericVirtualRegister(TrueTy); in tryFoldBoolSelectToLogic()
7188 Register Inner = MRI.createGenericVirtualRegister(CondTy); in tryFoldBoolSelectToLogic()
7191 Register Ext = MRI.createGenericVirtualRegister(TrueTy); in tryFoldBoolSelectToLogic()
7204 GSelect *Select = cast<GSelect>(MRI.getVRegDef(MO.getReg())); in matchSelectIMinMax()
7205 GICmp *Cmp = cast<GICmp>(MRI.getVRegDef(Select->getCondReg())); in matchSelectIMinMax()
7210 LLT DstTy = MRI.getType(DstReg); in matchSelectIMinMax()
7216 if (!MRI.hasOneNonDBGUse(Cmp->getReg(0))) in matchSelectIMinMax()
7279 LLT DestTy = MRI.getType(DestReg); in matchSimplifyNegMinMax()
7284 if (mi_match(DestReg, MRI, in matchSimplifyNegMinMax()
7289 MachineInstr *MinMaxMI = MRI.getVRegDef(MI.getOperand(2).getReg()); in matchSimplifyNegMinMax()
7328 GICmp *Cmp1 = getOpcodeDef<GICmp>(LHS, MRI); in tryFoldAndOrOrICmpsUsingRanges()
7333 GICmp *Cmp2 = getOpcodeDef<GICmp>(RHS, MRI); in tryFoldAndOrOrICmpsUsingRanges()
7338 if (!MRI.hasOneNonDBGUse(Cmp1->getReg(0)) || in tryFoldAndOrOrICmpsUsingRanges()
7339 !MRI.hasOneNonDBGUse(Cmp2->getReg(0))) in tryFoldAndOrOrICmpsUsingRanges()
7345 getIConstantVRegValWithLookThrough(Cmp1->getRHSReg(), MRI); in tryFoldAndOrOrICmpsUsingRanges()
7351 getIConstantVRegValWithLookThrough(Cmp2->getRHSReg(), MRI); in tryFoldAndOrOrICmpsUsingRanges()
7360 LLT CmpTy = MRI.getType(Cmp1->getReg(0)); in tryFoldAndOrOrICmpsUsingRanges()
7361 LLT CmpOperandTy = MRI.getType(R1); in tryFoldAndOrOrICmpsUsingRanges()
7378 if (GAdd *Add = getOpcodeDef<GAdd>(R1, MRI)) { in tryFoldAndOrOrICmpsUsingRanges()
7380 getIConstantVRegValWithLookThrough(Add->getRHSReg(), MRI); in tryFoldAndOrOrICmpsUsingRanges()
7386 if (GAdd *Add = getOpcodeDef<GAdd>(R2, MRI)) { in tryFoldAndOrOrICmpsUsingRanges()
7388 getIConstantVRegValWithLookThrough(Add->getRHSReg(), MRI); in tryFoldAndOrOrICmpsUsingRanges()
7486 GFCmp *Cmp1 = getOpcodeDef<GFCmp>(LHS, MRI); in tryFoldLogicOfFCmps()
7491 GFCmp *Cmp2 = getOpcodeDef<GFCmp>(RHS, MRI); in tryFoldLogicOfFCmps()
7495 LLT CmpTy = MRI.getType(Cmp1->getReg(0)); in tryFoldLogicOfFCmps()
7496 LLT CmpOperandTy = MRI.getType(Cmp1->getLHSReg()); in tryFoldLogicOfFCmps()
7502 !MRI.hasOneNonDBGUse(Logic->getReg(0)) || in tryFoldLogicOfFCmps()
7503 !MRI.hasOneNonDBGUse(Cmp1->getReg(0)) || in tryFoldLogicOfFCmps()
7504 !MRI.hasOneNonDBGUse(Cmp2->getReg(0)) || in tryFoldLogicOfFCmps()
7505 MRI.getType(Cmp1->getLHSReg()) != MRI.getType(Cmp2->getLHSReg())) in tryFoldLogicOfFCmps()
7586 LLT DstTy = MRI.getType(Dst); in matchAddOverflow()
7587 LLT CarryTy = MRI.getType(Carry); in matchAddOverflow()
7590 if (MRI.use_nodbg_empty(Carry) && in matchAddOverflow()
7642 GAdd *AddLHS = getOpcodeDef<GAdd>(LHS, MRI); in matchAddOverflow()
7643 if (MaybeRHS && AddLHS && MRI.hasOneNonDBGUse(Add->getReg(0)) && in matchAddOverflow()
7746 MachineInstr *Root = getDefIgnoringCopies(MO.getReg(), MRI); in applyBuildFnMO()
7760 LLT Ty = MRI.getType(Dst); in applyExpandFPowI()
7805 GAdd *Add = cast<GAdd>(MRI.getVRegDef(Sub->getLHSReg())); in matchFoldAPlusC1MinusC2()
7807 if (!MRI.hasOneNonDBGUse(Add->getReg(0))) in matchFoldAPlusC1MinusC2()
7810 APInt C2 = getIConstantFromReg(Sub->getRHSReg(), MRI); in matchFoldAPlusC1MinusC2()
7811 APInt C1 = getIConstantFromReg(Add->getRHSReg(), MRI); in matchFoldAPlusC1MinusC2()
7814 LLT DstTy = MRI.getType(Dst); in matchFoldAPlusC1MinusC2()
7828 GAdd *Add = cast<GAdd>(MRI.getVRegDef(Sub->getRHSReg())); in matchFoldC2MinusAPlusC1()
7830 if (!MRI.hasOneNonDBGUse(Add->getReg(0))) in matchFoldC2MinusAPlusC1()
7833 APInt C2 = getIConstantFromReg(Sub->getLHSReg(), MRI); in matchFoldC2MinusAPlusC1()
7834 APInt C1 = getIConstantFromReg(Add->getRHSReg(), MRI); in matchFoldC2MinusAPlusC1()
7837 LLT DstTy = MRI.getType(Dst); in matchFoldC2MinusAPlusC1()
7851 GSub *Sub2 = cast<GSub>(MRI.getVRegDef(Sub1->getLHSReg())); in matchFoldAMinusC1MinusC2()
7853 if (!MRI.hasOneNonDBGUse(Sub2->getReg(0))) in matchFoldAMinusC1MinusC2()
7856 APInt C2 = getIConstantFromReg(Sub1->getRHSReg(), MRI); in matchFoldAMinusC1MinusC2()
7857 APInt C1 = getIConstantFromReg(Sub2->getRHSReg(), MRI); in matchFoldAMinusC1MinusC2()
7860 LLT DstTy = MRI.getType(Dst); in matchFoldAMinusC1MinusC2()
7874 GSub *Sub2 = cast<GSub>(MRI.getVRegDef(Sub1->getLHSReg())); in matchFoldC1Minus2MinusC2()
7876 if (!MRI.hasOneNonDBGUse(Sub2->getReg(0))) in matchFoldC1Minus2MinusC2()
7879 APInt C2 = getIConstantFromReg(Sub1->getRHSReg(), MRI); in matchFoldC1Minus2MinusC2()
7880 APInt C1 = getIConstantFromReg(Sub2->getLHSReg(), MRI); in matchFoldC1Minus2MinusC2()
7883 LLT DstTy = MRI.getType(Dst); in matchFoldC1Minus2MinusC2()
7897 GSub *Sub = cast<GSub>(MRI.getVRegDef(Add->getLHSReg())); in matchFoldAMinusC1PlusC2()
7899 if (!MRI.hasOneNonDBGUse(Sub->getReg(0))) in matchFoldAMinusC1PlusC2()
7902 APInt C2 = getIConstantFromReg(Add->getRHSReg(), MRI); in matchFoldAMinusC1PlusC2()
7903 APInt C1 = getIConstantFromReg(Sub->getRHSReg(), MRI); in matchFoldAMinusC1PlusC2()
7906 LLT DstTy = MRI.getType(Dst); in matchFoldAMinusC1PlusC2()
7920 if (!MRI.hasOneNonDBGUse(Unmerge->getSourceReg())) in matchUnmergeValuesAnyExtBuildVector()
7923 const MachineInstr *Source = MRI.getVRegDef(Unmerge->getSourceReg()); in matchUnmergeValuesAnyExtBuildVector()
7925 LLT DstTy = MRI.getType(Unmerge->getReg(0)); in matchUnmergeValuesAnyExtBuildVector()
7952 const MachineInstr *NextSource = MRI.getVRegDef(Any->getSrcReg()); in matchUnmergeValuesAnyExtBuildVector()
7957 if (!MRI.hasOneNonDBGUse(BV->getReg(0))) in matchUnmergeValuesAnyExtBuildVector()
7964 LLT BigBvTy = MRI.getType(BV->getReg(0)); in matchUnmergeValuesAnyExtBuildVector()
8005 const LLT SrcTy = MRI.getType(Shuffle.getSrc1Reg()); in matchShuffleUndefRHS()
8048 if (getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF, Shuffle.getSrc1Reg(), MRI)) in matchShuffleDisjointMask()
8051 if (getOpcodeDef(TargetOpcode::G_IMPLICIT_DEF, Shuffle.getSrc2Reg(), MRI)) in matchShuffleDisjointMask()
8054 const LLT DstTy = MRI.getType(Shuffle.getReg(0)); in matchShuffleDisjointMask()
8055 const LLT Src1Ty = MRI.getType(Shuffle.getSrc1Reg()); in matchShuffleDisjointMask()
8102 LLT DstTy = MRI.getType(Dst); in matchSuboCarryOut()
8103 LLT CarryTy = MRI.getType(Carry); in matchSuboCarryOut()