Lines Matching refs:MRI

70   MRI = &MF.getRegInfo();  in setupMF()
83 const MachineRegisterInfo &MRI) const { in isVCC()
88 auto &RegClassOrBank = MRI.getRegClassOrRegBank(Reg); in isVCC()
92 const LLT Ty = MRI.getType(Reg); in isVCC()
96 return MRI.getVRegDef(Reg)->getOpcode() != AMDGPU::G_TRUNC && in isVCC()
114 if (MRI->getType(Dst.getReg()) == LLT::scalar(1)) in constrainCopyLikeIntrin()
118 = TRI.getConstrainedRegClassForOperand(Dst, *MRI); in constrainCopyLikeIntrin()
120 = TRI.getConstrainedRegClassForOperand(Src, *MRI); in constrainCopyLikeIntrin()
124 return RBI.constrainGenericRegister(Dst.getReg(), *DstRC, *MRI) && in constrainCopyLikeIntrin()
125 RBI.constrainGenericRegister(Src.getReg(), *SrcRC, *MRI); in constrainCopyLikeIntrin()
138 if (isVCC(DstReg, *MRI)) { in selectCOPY()
141 = TRI.getConstrainedRegClassForOperand(Dst, *MRI); in selectCOPY()
144 return RBI.constrainGenericRegister(DstReg, *RC, *MRI); in selectCOPY()
147 if (!isVCC(SrcReg, *MRI)) { in selectCOPY()
149 if (!RBI.constrainGenericRegister(DstReg, *TRI.getBoolRC(), *MRI)) in selectCOPY()
153 = TRI.getConstrainedRegClassForOperand(Src, *MRI); in selectCOPY()
156 getIConstantVRegValWithLookThrough(SrcReg, *MRI, true); in selectCOPY()
163 Register MaskedReg = MRI->createVirtualRegister(SrcRC); in selectCOPY()
183 if (!MRI->getRegClassOrNull(SrcReg)) in selectCOPY()
184 MRI->setRegClass(SrcReg, SrcRC); in selectCOPY()
190 TRI.getConstrainedRegClassForOperand(Dst, *MRI); in selectCOPY()
191 if (RC && !RBI.constrainGenericRegister(DstReg, *RC, *MRI)) in selectCOPY()
202 TRI.getConstrainedRegClassForOperand(MO, *MRI); in selectCOPY()
205 RBI.constrainGenericRegister(MO.getReg(), *RC, *MRI); in selectCOPY()
212 const LLT DefTy = MRI->getType(DefReg); in selectPHI()
225 MRI->getRegClassOrRegBank(DefReg); in selectPHI()
245 return RBI.constrainGenericRegister(DefReg, *DefRC, *MRI); in selectPHI()
255 Register DstReg = MRI->createVirtualRegister(&SubRC); in getSubOperand64()
298 unsigned Size = RBI.getSizeInBits(DstReg, *MRI, TRI); in selectG_AND_OR_XOR()
300 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_AND_OR_XOR()
322 LLT Ty = MRI->getType(DstReg); in selectG_ADD_SUB()
327 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_ADD_SUB()
353 Register UnusedCarry = MRI->createVirtualRegister(TRI.getWaveMaskRegClass()); in selectG_ADD_SUB()
376 Register DstLo = MRI->createVirtualRegister(&HalfRC); in selectG_ADD_SUB()
377 Register DstHi = MRI->createVirtualRegister(&HalfRC); in selectG_ADD_SUB()
389 Register CarryReg = MRI->createVirtualRegister(CarryRC); in selectG_ADD_SUB()
396 .addDef(MRI->createVirtualRegister(CarryRC), RegState::Dead) in selectG_ADD_SUB()
413 if (!RBI.constrainGenericRegister(DstReg, RC, *MRI)) in selectG_ADD_SUB()
432 if (isVCC(Dst1Reg, *MRI)) { in selectG_UADDO_USUBO_UADDE_USUBE()
457 if (MRI->use_nodbg_empty(Dst1Reg)) { in selectG_UADDO_USUBO_UADDE_USUBE()
462 if (!MRI->getRegClassOrNull(Dst1Reg)) in selectG_UADDO_USUBO_UADDE_USUBE()
463 MRI->setRegClass(Dst1Reg, &AMDGPU::SReg_32RegClass); in selectG_UADDO_USUBO_UADDE_USUBE()
466 if (!RBI.constrainGenericRegister(Dst0Reg, AMDGPU::SReg_32RegClass, *MRI) || in selectG_UADDO_USUBO_UADDE_USUBE()
467 !RBI.constrainGenericRegister(Src0Reg, AMDGPU::SReg_32RegClass, *MRI) || in selectG_UADDO_USUBO_UADDE_USUBE()
468 !RBI.constrainGenericRegister(Src1Reg, AMDGPU::SReg_32RegClass, *MRI)) in selectG_UADDO_USUBO_UADDE_USUBE()
473 AMDGPU::SReg_32RegClass, *MRI)) in selectG_UADDO_USUBO_UADDE_USUBE()
503 LLT DstTy = MRI->getType(DstReg); in selectG_EXTRACT()
504 LLT SrcTy = MRI->getType(SrcReg); in selectG_EXTRACT()
519 TRI.getConstrainedRegClassForOperand(I.getOperand(0), *MRI); in selectG_EXTRACT()
520 if (!DstRC || !RBI.constrainGenericRegister(DstReg, *DstRC, *MRI)) in selectG_EXTRACT()
523 const RegisterBank *SrcBank = RBI.getRegBank(SrcReg, *MRI, TRI); in selectG_EXTRACT()
534 SrcReg = constrainOperandRegClass(*MF, TRI, *MRI, TII, RBI, I, in selectG_EXTRACT()
547 LLT DstTy = MRI->getType(DstReg); in selectG_MERGE_VALUES()
548 LLT SrcTy = MRI->getType(MI.getOperand(1).getReg()); in selectG_MERGE_VALUES()
555 const RegisterBank *DstBank = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_MERGE_VALUES()
571 = TRI.getConstrainedRegClassForOperand(Src, *MRI); in selectG_MERGE_VALUES()
572 if (SrcRC && !RBI.constrainGenericRegister(Src.getReg(), *SrcRC, *MRI)) in selectG_MERGE_VALUES()
576 if (!RBI.constrainGenericRegister(DstReg, *DstRC, *MRI)) in selectG_MERGE_VALUES()
591 LLT DstTy = MRI->getType(DstReg0); in selectG_UNMERGE_VALUES()
592 LLT SrcTy = MRI->getType(SrcReg); in selectG_UNMERGE_VALUES()
597 const RegisterBank *SrcBank = RBI.getRegBank(SrcReg, *MRI, TRI); in selectG_UNMERGE_VALUES()
601 if (!SrcRC || !RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI)) in selectG_UNMERGE_VALUES()
615 if (!SrcRC || !RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI)) in selectG_UNMERGE_VALUES()
619 TRI.getConstrainedRegClassForOperand(Dst, *MRI); in selectG_UNMERGE_VALUES()
620 if (DstRC && !RBI.constrainGenericRegister(Dst.getReg(), *DstRC, *MRI)) in selectG_UNMERGE_VALUES()
634 LLT SrcTy = MRI->getType(Src0); in selectG_BUILD_VECTOR()
645 if (MRI->getType(Dst) != LLT::fixed_vector(2, 16) || in selectG_BUILD_VECTOR()
650 const RegisterBank *DstBank = RBI.getRegBank(Dst, *MRI, TRI); in selectG_BUILD_VECTOR()
664 auto ConstSrc1 = getAnyConstantVRegValWithLookThrough(Src1, *MRI, true, true); in selectG_BUILD_VECTOR()
667 getAnyConstantVRegValWithLookThrough(Src0, *MRI, true, true); in selectG_BUILD_VECTOR()
679 return RBI.constrainGenericRegister(Dst, AMDGPU::VGPR_32RegClass, *MRI); in selectG_BUILD_VECTOR()
685 return RBI.constrainGenericRegister(Dst, AMDGPU::SReg_32RegClass, *MRI); in selectG_BUILD_VECTOR()
695 MachineInstr *Src1Def = getDefIgnoringCopies(Src1, *MRI); in selectG_BUILD_VECTOR()
701 return RBI.constrainGenericRegister(Dst, RC, *MRI) && in selectG_BUILD_VECTOR()
702 RBI.constrainGenericRegister(Src0, RC, *MRI); in selectG_BUILD_VECTOR()
707 Register TmpReg = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectG_BUILD_VECTOR()
741 Src0, *MRI, m_OneUse(m_GLShr(m_Reg(ShiftSrc0), m_SpecificICst(16)))); in selectG_BUILD_VECTOR()
744 Src1, *MRI, m_OneUse(m_GLShr(m_Reg(ShiftSrc1), m_SpecificICst(16)))); in selectG_BUILD_VECTOR()
756 getAnyConstantVRegValWithLookThrough(Src1, *MRI, true, true); in selectG_BUILD_VECTOR()
786 const TargetRegisterClass *RC = TRI.getConstrainedRegClassForOperand(MO, *MRI); in selectG_IMPLICIT_DEF()
787 if ((!RC && !MRI->getRegBankOrNull(MO.getReg())) || in selectG_IMPLICIT_DEF()
788 (RC && RBI.constrainGenericRegister(MO.getReg(), *RC, *MRI))) { in selectG_IMPLICIT_DEF()
802 LLT Src1Ty = MRI->getType(Src1Reg); in selectG_INSERT()
804 unsigned DstSize = MRI->getType(DstReg).getSizeInBits(); in selectG_INSERT()
821 const RegisterBank *DstBank = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_INSERT()
827 const RegisterBank *Src0Bank = RBI.getRegBank(Src0Reg, *MRI, TRI); in selectG_INSERT()
828 const RegisterBank *Src1Bank = RBI.getRegBank(Src1Reg, *MRI, TRI); in selectG_INSERT()
840 if (!RBI.constrainGenericRegister(DstReg, *DstRC, *MRI) || in selectG_INSERT()
841 !RBI.constrainGenericRegister(Src0Reg, *Src0RC, *MRI) || in selectG_INSERT()
842 !RBI.constrainGenericRegister(Src1Reg, *Src1RC, *MRI)) in selectG_INSERT()
861 assert(RBI.getRegBank(DstReg, *MRI, TRI)->getID() == AMDGPU::VGPRRegBankID && in selectG_SBFX_UBFX()
863 assert(MRI->getType(MI.getOperand(0).getReg()).getSizeInBits() == 32 && in selectG_SBFX_UBFX()
886 if (!RBI.constrainGenericRegister(M0Val, AMDGPU::SReg_32RegClass, *MRI) || in selectInterpP1F16()
887 !RBI.constrainGenericRegister(Dst, AMDGPU::VGPR_32RegClass, *MRI) || in selectInterpP1F16()
888 !RBI.constrainGenericRegister(Src0, AMDGPU::VGPR_32RegClass, *MRI)) in selectInterpP1F16()
898 Register InterpMov = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectInterpP1F16()
944 getIConstantVRegValWithLookThrough(LaneSelect, *MRI); in selectWritelane()
953 getIConstantVRegValWithLookThrough(Val, *MRI); in selectWritelane()
967 RBI.constrainGenericRegister(LaneSelect, AMDGPU::SReg_32_XM0RegClass, *MRI); in selectWritelane()
987 LLT Ty = MRI->getType(Dst0); in selectDivScale()
1042 MRI->setRegClass(Reg, TRI.getWaveMaskRegClass()); in selectG_INTRINSIC()
1316 unsigned Size = RBI.getSizeInBits(SrcReg, *MRI, TRI); in selectG_ICMP_or_FCMP()
1321 if (!isVCC(CCReg, *MRI)) { in selectG_ICMP_or_FCMP()
1332 RBI.constrainGenericRegister(CCReg, AMDGPU::SReg_32RegClass, *MRI); in selectG_ICMP_or_FCMP()
1349 *TRI.getBoolRC(), *MRI); in selectG_ICMP_or_FCMP()
1357 if (isVCC(Dst, *MRI)) in selectIntrinsicCmp()
1360 LLT DstTy = MRI->getType(Dst); in selectIntrinsicCmp()
1367 unsigned Size = RBI.getSizeInBits(SrcReg, *MRI, TRI); in selectIntrinsicCmp()
1377 return RBI.constrainGenericRegister(Dst, *TRI.getBoolRC(), *MRI); in selectIntrinsicCmp()
1405 RBI.constrainGenericRegister(Dst, *TRI.getBoolRC(), *MRI); in selectIntrinsicCmp()
1417 const unsigned Size = MRI->getType(DstReg).getSizeInBits(); in selectBallot()
1427 getIConstantVRegValWithLookThrough(I.getOperand(2).getReg(), *MRI); in selectBallot()
1437 Register HiReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectBallot()
1475 const RegisterBank *DstBank = RBI.getRegBank(DstReg, *MRI, TRI); in selectRelocConstant()
1477 if (!DstRC || !RBI.constrainGenericRegister(DstReg, *DstRC, *MRI)) in selectRelocConstant()
1501 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectGroupStaticSize()
1534 = TRI.getConstrainedRegClassForOperand(Dst, *MRI); in selectReturnAddress()
1536 !RBI.constrainGenericRegister(DstReg, *RC, *MRI)) in selectReturnAddress()
1572 if (!MRI->getRegClassOrNull(Reg)) in selectEndCfIntrinsic()
1573 MRI->setRegClass(Reg, TRI.getWaveMaskRegClass()); in selectEndCfIntrinsic()
1633 if (!RBI.constrainGenericRegister(M0Val, AMDGPU::SReg_32RegClass, *MRI)) in selectDSOrderedIntrinsic()
1671 const RegisterBank *OffsetRB = RBI.getRegBank(BaseOffset, *MRI, TRI); in selectDSGWSIntrinsic()
1675 MachineInstr *OffsetDef = getDefIgnoringCopies(BaseOffset, *MRI); in selectDSGWSIntrinsic()
1689 OffsetDef = getDefIgnoringCopies(BaseOffset, *MRI); in selectDSGWSIntrinsic()
1703 AMDGPU::getBaseWithConstantOffset(*MRI, BaseOffset, KB); in selectDSGWSIntrinsic()
1708 if (!RBI.constrainGenericRegister(BaseOffset, AMDGPU::VGPR_32RegClass, *MRI)) in selectDSGWSIntrinsic()
1715 AMDGPU::SReg_32RegClass, *MRI)) in selectDSGWSIntrinsic()
1719 Register M0Base = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectDSGWSIntrinsic()
1738 if (!RBI.constrainGenericRegister(VSrc, AMDGPU::VGPR_32RegClass, *MRI)) in selectDSGWSIntrinsic()
1754 LLT PtrTy = MRI->getType(PtrBase); in selectDSAppendConsume()
1772 if (!RBI.constrainGenericRegister(PtrBase, AMDGPU::SReg_32RegClass, *MRI)) in selectDSAppendConsume()
1872 LLT Ty = MRI->getType(VDataIn); in selectImageIntrinsic()
1894 VDataTy = MRI->getType(VDataIn); in selectImageIntrinsic()
1898 VDataTy = MRI->getType(VDataOut); in selectImageIntrinsic()
1937 NumVAddrDwords += (MRI->getType(Addr).getSizeInBits() + 31) / 32; in selectImageIntrinsic()
1996 const bool Is64 = MRI->getType(VDataOut).getSizeInBits() == 64; in selectImageIntrinsic()
1998 Register TmpReg = MRI->createVirtualRegister( in selectImageIntrinsic()
2003 if (!MRI->use_empty(VDataOut)) { in selectImageIntrinsic()
2060 Register Tied = MRI->cloneVirtualRegister(VDataOut); in selectImageIntrinsic()
2061 Register Zero = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectImageIntrinsic()
2064 auto Parts = TRI.getRegSplitParts(MRI->getRegClass(Tied), 4); in selectImageIntrinsic()
2075 Register Undef = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectImageIntrinsic()
2182 unsigned Size = RBI.getSizeInBits(DstReg, *MRI, TRI); in selectG_SELECT()
2186 if (!isVCC(CCReg, *MRI)) { in selectG_SELECT()
2195 if (!MRI->getRegClassOrNull(CCReg)) in selectG_SELECT()
2196 MRI->setRegClass(CCReg, TRI.getConstrainedRegClassForOperand(CCOp, *MRI)); in selectG_SELECT()
2249 const LLT DstTy = MRI->getType(DstReg); in selectG_TRUNC()
2250 const LLT SrcTy = MRI->getType(SrcReg); in selectG_TRUNC()
2253 const RegisterBank *SrcRB = RBI.getRegBank(SrcReg, *MRI, TRI); in selectG_TRUNC()
2260 DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_TRUNC()
2277 if (!RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI) || in selectG_TRUNC()
2278 !RBI.constrainGenericRegister(DstReg, *DstRC, *MRI)) { in selectG_TRUNC()
2287 Register LoReg = MRI->createVirtualRegister(DstRC); in selectG_TRUNC()
2288 Register HiReg = MRI->createVirtualRegister(DstRC); in selectG_TRUNC()
2308 Register TmpReg0 = MRI->createVirtualRegister(DstRC); in selectG_TRUNC()
2309 Register TmpReg1 = MRI->createVirtualRegister(DstRC); in selectG_TRUNC()
2310 Register ImmReg = MRI->createVirtualRegister(DstRC); in selectG_TRUNC()
2361 if (!RBI.constrainGenericRegister(SrcReg, *SrcWithSubRC, *MRI)) in selectG_TRUNC()
2381 Register Reg, const MachineRegisterInfo &MRI, in getArtifactRegBank() argument
2383 const RegClassOrRegBank &RegClassOrBank = MRI.getRegClassOrRegBank(Reg); in getArtifactRegBank()
2401 const LLT DstTy = MRI->getType(DstReg); in selectG_SZA_EXT()
2402 const LLT SrcTy = MRI->getType(SrcReg); in selectG_SZA_EXT()
2410 const RegisterBank *SrcBank = getArtifactRegBank(SrcReg, *MRI, TRI); in selectG_SZA_EXT()
2419 const RegisterBank *DstBank = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_SZA_EXT()
2423 Register UndefReg = MRI->createVirtualRegister(SrcRC); in selectG_SZA_EXT()
2432 return RBI.constrainGenericRegister(DstReg, *DstRC, *MRI) && in selectG_SZA_EXT()
2433 RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI); in selectG_SZA_EXT()
2463 if (!RBI.constrainGenericRegister(SrcReg, SrcRC, *MRI)) in selectG_SZA_EXT()
2472 return RBI.constrainGenericRegister(DstReg, AMDGPU::SReg_32RegClass, *MRI); in selectG_SZA_EXT()
2478 Register HiReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_SZA_EXT()
2496 *MRI); in selectG_SZA_EXT()
2505 Register ExtReg = MRI->createVirtualRegister(&AMDGPU::SReg_64RegClass); in selectG_SZA_EXT()
2506 Register UndefReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_SZA_EXT()
2521 return RBI.constrainGenericRegister(DstReg, AMDGPU::SReg_64RegClass, *MRI); in selectG_SZA_EXT()
2537 return RBI.constrainGenericRegister(DstReg, AMDGPU::SReg_32RegClass, *MRI); in selectG_SZA_EXT()
2543 static bool isExtractHiElt(MachineRegisterInfo &MRI, Register In, in isExtractHiElt() argument
2546 if (mi_match(In, MRI, in isExtractHiElt()
2559 const RegisterBank *DstRB = RBI.getRegBank(Dst, *MRI, TRI); in selectG_FPEXT()
2565 if (MRI->getType(Dst) == LLT::scalar(32) && in selectG_FPEXT()
2566 MRI->getType(Src) == LLT::scalar(16)) { in selectG_FPEXT()
2567 if (isExtractHiElt(*MRI, Src, Src)) { in selectG_FPEXT()
2572 return RBI.constrainGenericRegister(Dst, AMDGPU::SReg_32RegClass, *MRI); in selectG_FPEXT()
2583 unsigned Size = MRI->getType(DstReg).getSizeInBits(); in selectG_CONSTANT()
2597 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_CONSTANT()
2636 Register LoReg = MRI->createVirtualRegister(RC); in selectG_CONSTANT()
2637 Register HiReg = MRI->createVirtualRegister(RC); in selectG_CONSTANT()
2656 TRI.getConstrainedRegClassForOperand(ResInst->getOperand(0), *MRI); in selectG_CONSTANT()
2659 return RBI.constrainGenericRegister(DstReg, *DstRC, *MRI); in selectG_CONSTANT()
2675 const RegisterBank *DstRB = RBI.getRegBank(Dst, *MRI, TRI); in selectG_FNEG()
2677 MRI->getType(Dst) != LLT::scalar(64)) in selectG_FNEG()
2681 MachineInstr *Fabs = getOpcodeDef(TargetOpcode::G_FABS, Src, *MRI); in selectG_FNEG()
2685 if (!RBI.constrainGenericRegister(Src, AMDGPU::SReg_64RegClass, *MRI) || in selectG_FNEG()
2686 !RBI.constrainGenericRegister(Dst, AMDGPU::SReg_64RegClass, *MRI)) in selectG_FNEG()
2691 Register LoReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FNEG()
2692 Register HiReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FNEG()
2693 Register ConstReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FNEG()
2694 Register OpReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FNEG()
2721 const RegisterBank *DstRB = RBI.getRegBank(Dst, *MRI, TRI); in selectG_FABS()
2723 MRI->getType(Dst) != LLT::scalar(64)) in selectG_FABS()
2729 Register LoReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FABS()
2730 Register HiReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FABS()
2731 Register ConstReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FABS()
2732 Register OpReg = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectG_FABS()
2734 if (!RBI.constrainGenericRegister(Src, AMDGPU::SReg_64RegClass, *MRI) || in selectG_FABS()
2735 !RBI.constrainGenericRegister(Dst, AMDGPU::SReg_64RegClass, *MRI)) in selectG_FABS()
2766 const MachineRegisterInfo &MRI, SmallVectorImpl<GEPInfo> &AddrInfo) const { in getAddrModeInfo() argument
2770 MRI.getUniqueVRegDef(Load.getOperand(OpNo).getReg()); in getAddrModeInfo()
2781 const MachineInstr *OpDef = MRI.getUniqueVRegDef(GEPOp.getReg()); in getAddrModeInfo()
2790 const RegisterBank *OpBank = RBI.getRegBank(GEPOp.getReg(), MRI, TRI); in getAddrModeInfo()
2798 getAddrModeInfo(*PtrMI, MRI, AddrInfo); in getAddrModeInfo()
2802 return RBI.getRegBank(Reg, *MRI, TRI)->getID() == AMDGPU::SGPRRegBankID; in isSGPR()
2824 return RBI.getRegBank(MI.getOperand(0).getReg(), *MRI, TRI)->getID() == in isInstrUniform()
2840 const LLT PtrTy = MRI->getType(I.getOperand(1).getReg()); in initM0()
2858 static bool isVCmpResult(Register Reg, MachineRegisterInfo &MRI) { in isVCmpResult() argument
2862 MachineInstr &MI = *MRI.getUniqueVRegDef(Reg); in isVCmpResult()
2866 return isVCmpResult(MI.getOperand(1).getReg(), MRI); in isVCmpResult()
2870 return isVCmpResult(MI.getOperand(1).getReg(), MRI) && in isVCmpResult()
2871 isVCmpResult(MI.getOperand(2).getReg(), MRI); in isVCmpResult()
2894 if (!isVCC(CondReg, *MRI)) { in selectG_BRCOND()
2895 if (MRI->getType(CondReg) != LLT::scalar(32)) in selectG_BRCOND()
2906 if (!isVCmpResult(CondReg, *MRI)) { in selectG_BRCOND()
2911 Register TmpReg = MRI->createVirtualRegister(TRI.getBoolRC()); in selectG_BRCOND()
2924 if (!MRI->getRegClassOrNull(CondReg)) in selectG_BRCOND()
2925 MRI->setRegClass(CondReg, ConstrainRC); in selectG_BRCOND()
2939 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_GLOBAL_VALUE()
2946 DstReg, IsVGPR ? AMDGPU::VGPR_32RegClass : AMDGPU::SReg_32RegClass, *MRI); in selectG_GLOBAL_VALUE()
2953 LLT Ty = MRI->getType(DstReg); in selectG_PTRMASK()
2954 LLT MaskTy = MRI->getType(MaskReg); in selectG_PTRMASK()
2958 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_PTRMASK()
2959 const RegisterBank *SrcRB = RBI.getRegBank(SrcReg, *MRI, TRI); in selectG_PTRMASK()
2960 const RegisterBank *MaskRB = RBI.getRegBank(MaskReg, *MRI, TRI); in selectG_PTRMASK()
2993 if (!RBI.constrainGenericRegister(DstReg, *DstRC, *MRI) || in selectG_PTRMASK()
2994 !RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI) || in selectG_PTRMASK()
2995 !RBI.constrainGenericRegister(MaskReg, *MaskRC, *MRI)) in selectG_PTRMASK()
3012 Register HiReg = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3013 Register LoReg = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3028 Register MaskLo = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3029 MaskedLo = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3042 Register MaskHi = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3043 MaskedHi = MRI->createVirtualRegister(&RegRC); in selectG_PTRMASK()
3064 computeIndirectRegIndex(MachineRegisterInfo &MRI, const SIRegisterInfo &TRI, in computeIndirectRegIndex() argument
3071 AMDGPU::getBaseWithConstantOffset(MRI, IdxReg, &KnownBits); in computeIndirectRegIndex()
3094 LLT DstTy = MRI->getType(DstReg); in selectG_EXTRACT_VECTOR_ELT()
3095 LLT SrcTy = MRI->getType(SrcReg); in selectG_EXTRACT_VECTOR_ELT()
3097 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectG_EXTRACT_VECTOR_ELT()
3098 const RegisterBank *SrcRB = RBI.getRegBank(SrcReg, *MRI, TRI); in selectG_EXTRACT_VECTOR_ELT()
3099 const RegisterBank *IdxRB = RBI.getRegBank(IdxReg, *MRI, TRI); in selectG_EXTRACT_VECTOR_ELT()
3112 if (!RBI.constrainGenericRegister(SrcReg, *SrcRC, *MRI) || in selectG_EXTRACT_VECTOR_ELT()
3113 !RBI.constrainGenericRegister(DstReg, *DstRC, *MRI) || in selectG_EXTRACT_VECTOR_ELT()
3114 !RBI.constrainGenericRegister(IdxReg, AMDGPU::SReg_32RegClass, *MRI)) in selectG_EXTRACT_VECTOR_ELT()
3123 *MRI, TRI, SrcRC, IdxReg, DstTy.getSizeInBits() / 8, *KB); in selectG_EXTRACT_VECTOR_ELT()
3172 LLT VecTy = MRI->getType(DstReg); in selectG_INSERT_VECTOR_ELT()
3173 LLT ValTy = MRI->getType(ValReg); in selectG_INSERT_VECTOR_ELT()
3177 const RegisterBank *VecRB = RBI.getRegBank(VecReg, *MRI, TRI); in selectG_INSERT_VECTOR_ELT()
3178 const RegisterBank *ValRB = RBI.getRegBank(ValReg, *MRI, TRI); in selectG_INSERT_VECTOR_ELT()
3179 const RegisterBank *IdxRB = RBI.getRegBank(IdxReg, *MRI, TRI); in selectG_INSERT_VECTOR_ELT()
3193 if (!RBI.constrainGenericRegister(VecReg, *VecRC, *MRI) || in selectG_INSERT_VECTOR_ELT()
3194 !RBI.constrainGenericRegister(DstReg, *VecRC, *MRI) || in selectG_INSERT_VECTOR_ELT()
3195 !RBI.constrainGenericRegister(ValReg, *ValRC, *MRI) || in selectG_INSERT_VECTOR_ELT()
3196 !RBI.constrainGenericRegister(IdxReg, AMDGPU::SReg_32RegClass, *MRI)) in selectG_INSERT_VECTOR_ELT()
3204 computeIndirectRegIndex(*MRI, TRI, VecRC, IdxReg, ValSize / 8, *KB); in selectG_INSERT_VECTOR_ELT()
3254 getIConstantVRegValWithLookThrough(VOffset, *MRI); in selectBufferLoadLds()
3288 Register IdxReg = MRI->createVirtualRegister(TRI.getVGPR64Class()); in selectBufferLoadLds()
3332 static Register matchZeroExtendFromS32(MachineRegisterInfo &MRI, Register Reg) { in matchZeroExtendFromS32() argument
3334 if (mi_match(Reg, MRI, m_GZExt(m_Reg(ZExtSrc)))) in matchZeroExtendFromS32()
3335 return MRI.getType(ZExtSrc) == LLT::scalar(32) ? ZExtSrc : Register(); in matchZeroExtendFromS32()
3338 const MachineInstr *Def = getDefIgnoringCopies(Reg, MRI); in matchZeroExtendFromS32()
3343 MRI.getType(Def->getOperand(0).getReg()) == LLT::scalar(64)); in matchZeroExtendFromS32()
3344 if (mi_match(Def->getOperand(2).getReg(), MRI, m_ZeroInt())) { in matchZeroExtendFromS32()
3379 auto AddrDef = getDefSrcRegIgnoringCopies(Addr, *MRI); in selectGlobalLoadLds()
3384 getSrcRegIgnoringCopies(AddrDef->MI->getOperand(1).getReg(), *MRI); in selectGlobalLoadLds()
3387 if (Register Off = matchZeroExtendFromS32(*MRI, PtrBaseOffset)) { in selectGlobalLoadLds()
3398 VOffset = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectGlobalLoadLds()
3502 const RegisterBank *DstRB = RBI.getRegBank(DstReg, *MRI, TRI); in selectWaveAddress()
3520 if (!RBI.constrainGenericRegister(DstReg, RC, *MRI)) in selectWaveAddress()
3529 if (!RBI.constrainGenericRegister(SrcReg, AMDGPU::SReg_32RegClass, *MRI)) in selectStackRestore()
3532 MachineInstr *DefMI = MRI->getVRegDef(SrcReg); in selectStackRestore()
3540 WaveAddr = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectStackRestore()
3660 if (MRI->getType(I.getOperand(1).getReg()) != LLT::scalar(1) && in select()
3719 MachineInstr *MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3ModsImpl()
3724 MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3ModsImpl()
3729 getConstantFPVRegVal(MI->getOperand(1).getReg(), *MRI); in selectVOP3ModsImpl()
3751 RBI.getRegBank(Src, *MRI, TRI)->getID() != AMDGPU::VGPRRegBankID) { in copyToVGPRIfSrcFolded()
3756 Register VGPRSrc = MRI->cloneVirtualRegister(Root.getReg()); in copyToVGPRIfSrcFolded()
3866 const MachineInstr *Def = getDefIgnoringCopies(Reg, *MRI); in selectVOP3NoMods()
3876 Register Src, const MachineRegisterInfo &MRI, bool IsDOT) const { in selectVOP3PModsImpl() argument
3878 MachineInstr *MI = MRI.getVRegDef(Src); in selectVOP3PModsImpl()
3883 MRI.getType(Src) == LLT::fixed_vector(2, 16)) { in selectVOP3PModsImpl()
3886 MI = MRI.getVRegDef(Src); in selectVOP3PModsImpl()
3902 MachineRegisterInfo &MRI in selectVOP3PMods() local
3907 std::tie(Src, Mods) = selectVOP3PModsImpl(Root.getReg(), MRI); in selectVOP3PMods()
3917 MachineRegisterInfo &MRI in selectVOP3PModsDOT() local
3922 std::tie(Src, Mods) = selectVOP3PModsImpl(Root.getReg(), MRI, true); in selectVOP3PModsDOT()
3961 MachineRegisterInfo &MRI) { in buildRegSequence() argument
3979 .addDef(MRI.createVirtualRegister(DstRegClass)); in buildRegSequence()
3990 MachineRegisterInfo &MRI) { in selectWMMAModsNegAbs() argument
3997 if (!mi_match(El, MRI, m_GFabs(m_Reg(FabsSrc)))) in selectWMMAModsNegAbs()
4003 Src = buildRegSequence(Elts, InsertPt, MRI); in selectWMMAModsNegAbs()
4007 Src = buildRegSequence(NegAbsElts, InsertPt, MRI); in selectWMMAModsNegAbs()
4013 Src = buildRegSequence(Elts, InsertPt, MRI); in selectWMMAModsNegAbs()
4024 if (GBuildVector *BV = dyn_cast<GBuildVector>(MRI->getVRegDef(Src))) { in selectWMMAModsF32NegAbs()
4026 MachineInstr *ElF32 = MRI->getVRegDef(BV->getSourceReg(i)); in selectWMMAModsF32NegAbs()
4039 *MRI); in selectWMMAModsF32NegAbs()
4053 if (GConcatVectors *CV = dyn_cast<GConcatVectors>(MRI->getVRegDef(Src))) { in selectWMMAModsF16Neg()
4056 if (!mi_match(CV->getSourceReg(i), *MRI, m_GFNeg(m_Reg(FNegSrc)))) in selectWMMAModsF16Neg()
4065 Src = buildRegSequence(EltsV2F16, Root.getParent(), *MRI); in selectWMMAModsF16Neg()
4080 if (GConcatVectors *CV = dyn_cast<GConcatVectors>(MRI->getVRegDef(Src))) { in selectWMMAModsF16NegAbs()
4082 MachineInstr *ElV2F16 = MRI->getVRegDef(CV->getSourceReg(i)); in selectWMMAModsF16NegAbs()
4096 *MRI); in selectWMMAModsF16NegAbs()
4107 if (mi_match(Root.getReg(), *MRI, m_GFCstOrSplat(FPValReg))) { in selectWMMAVISrc()
4119 if (mi_match(Root.getReg(), *MRI, m_ICstOrSplat(ICst))) { in selectWMMAVISrc()
4132 getDefIgnoringCopies(Root.getReg(), *MRI)->getOperand(0).getReg(); in selectSWMMACIndex8()
4137 if (mi_match(Src, *MRI, m_GLShr(m_Reg(ShiftSrc), m_GCst(ShiftAmt))) && in selectSWMMACIndex8()
4138 MRI->getType(ShiftSrc).getSizeInBits() == 32 && in selectSWMMACIndex8()
4154 getDefIgnoringCopies(Root.getReg(), *MRI)->getOperand(0).getReg(); in selectSWMMACIndex16()
4159 if (mi_match(Src, *MRI, m_GLShr(m_Reg(ShiftSrc), m_GCst(ShiftAmt))) && in selectSWMMACIndex16()
4160 MRI->getType(ShiftSrc).getSizeInBits() == 32 && in selectSWMMACIndex16()
4231 getAddrModeInfo(*MI, *MRI, AddrInfo); in selectSmrdOffset()
4246 matchZeroExtendFromS32(*MRI, GEPI2.SgprParts[1])) { in selectSmrdOffset()
4271 *SOffset = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectSmrdOffset()
4278 if (Register OffsetReg = matchZeroExtendFromS32(*MRI, GEPI.SgprParts[1])) { in selectSmrdOffset()
4302 getAddrModeInfo(*Root.getParent(), *MRI, AddrInfo); in selectSmrdImm32()
4355 getPtrBaseWithConstantOffset(Root.getReg(), *MRI); in selectFlatOffsetImpl()
4408 std::tie(PtrBase, ConstOffset) = getPtrBaseWithConstantOffset(Addr, *MRI); in selectGlobalSAddr()
4416 auto PtrBaseDef = getDefSrcRegIgnoringCopies(PtrBase, *MRI); in selectGlobalSAddr()
4432 MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectGlobalSAddr()
4463 auto AddrDef = getDefSrcRegIgnoringCopies(Addr, *MRI); in selectGlobalSAddr()
4467 getSrcRegIgnoringCopies(AddrDef->MI->getOperand(1).getReg(), *MRI); in selectGlobalSAddr()
4474 if (Register VOffset = matchZeroExtendFromS32(*MRI, PtrBaseOffset)) { in selectGlobalSAddr()
4498 Register VOffset = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectGlobalSAddr()
4519 std::tie(PtrBase, ConstOffset) = getPtrBaseWithConstantOffset(Addr, *MRI); in selectScratchSAddr()
4528 auto AddrDef = getDefSrcRegIgnoringCopies(Addr, *MRI); in selectScratchSAddr()
4542 auto LHSDef = getDefSrcRegIgnoringCopies(LHS, *MRI); in selectScratchSAddr()
4543 auto RHSDef = getDefSrcRegIgnoringCopies(RHS, *MRI); in selectScratchSAddr()
4551 SAddr = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectScratchSAddr()
4596 std::tie(PtrBase, ConstOffset) = getPtrBaseWithConstantOffset(Addr, *MRI); in selectScratchSVAddr()
4605 auto AddrDef = getDefSrcRegIgnoringCopies(Addr, *MRI); in selectScratchSVAddr()
4610 if (RBI.getRegBank(RHS, *MRI, TRI)->getID() != AMDGPU::VGPRRegBankID) in selectScratchSVAddr()
4614 auto LHSDef = getDefSrcRegIgnoringCopies(LHS, *MRI); in selectScratchSVAddr()
4654 if (mi_match(Root.getReg(), *MRI, m_ICst(Offset)) && in selectMUBUFScratchOffen()
4656 Register HighBits = MRI->createVirtualRegister(&AMDGPU::VGPR_32RegClass); in selectMUBUFScratchOffen()
4687 if (const MachineInstr *RootDef = MRI->getVRegDef(Root.getReg())) { in selectMUBUFScratchOffen()
4690 std::tie(PtrBase, ConstOffset) = getPtrBaseWithConstantOffset(VAddr, *MRI); in selectMUBUFScratchOffen()
4695 const MachineInstr *PtrBaseDef = MRI->getVRegDef(PtrBase); in selectMUBUFScratchOffen()
4766 MachineInstr *AddrMI = getDefIgnoringCopies(Addr, *MRI); in isFlatScratchBaseLegal()
4781 getIConstantVRegValWithLookThrough(RHS, *MRI); in isFlatScratchBaseLegal()
4797 MachineInstr *AddrMI = getDefIgnoringCopies(Addr, *MRI); in isFlatScratchBaseLegalSV()
4821 MachineInstr *AddrMI = getDefIgnoringCopies(Addr, *MRI); in isFlatScratchBaseLegalSVImm()
4824 getDefSrcRegIgnoringCopies(Base, *MRI); in isFlatScratchBaseLegalSVImm()
4826 getIConstantVRegValWithLookThrough(AddrMI->getOperand(2).getReg(), *MRI); in isFlatScratchBaseLegalSVImm()
4849 getIConstantVRegVal(MI.getOperand(2).getReg(), *MRI); in isUnneededShiftMask()
4867 getDefSrcRegIgnoringCopies(Reg, *MRI); in selectMUBUFScratchOffset()
4887 if (mi_match(Reg, *MRI, in selectMUBUFScratchOffset()
4892 MachineInstr *BasePtrDef = getDefIgnoringCopies(BasePtr, *MRI); in selectMUBUFScratchOffset()
4908 if (!mi_match(Root.getReg(), *MRI, m_ICst(Offset)) || in selectMUBUFScratchOffset()
4925 const MachineInstr *RootDef = MRI->getVRegDef(Root.getReg()); in selectDS1Addr1OffsetImpl()
4934 getPtrBaseWithConstantOffset(Root.getReg(), *MRI); in selectDS1Addr1OffsetImpl()
4945 } else if (mi_match(Root.getReg(), *MRI, m_ICst(ConstAddr))) { in selectDS1Addr1OffsetImpl()
4990 const MachineInstr *RootDef = MRI->getVRegDef(Root.getReg()); in selectDSReadWrite2Impl()
4999 getPtrBaseWithConstantOffset(Root.getReg(), *MRI); in selectDSReadWrite2Impl()
5011 } else if (mi_match(Root.getReg(), *MRI, m_ICst(ConstAddr))) { in selectDSReadWrite2Impl()
5025 Register Root, const MachineRegisterInfo &MRI) const { in getPtrBaseWithConstantOffset()
5026 MachineInstr *RootI = getDefIgnoringCopies(Root, MRI); in getPtrBaseWithConstantOffset()
5032 getIConstantVRegValWithLookThrough(RHS.getReg(), MRI); in getPtrBaseWithConstantOffset()
5044 static Register buildRSRC(MachineIRBuilder &B, MachineRegisterInfo &MRI, in buildRSRC() argument
5047 Register RSrc2 = MRI.createVirtualRegister(&AMDGPU::SReg_32RegClass); in buildRSRC()
5048 Register RSrc3 = MRI.createVirtualRegister(&AMDGPU::SReg_32RegClass); in buildRSRC()
5049 Register RSrcHi = MRI.createVirtualRegister(&AMDGPU::SReg_64RegClass); in buildRSRC()
5050 Register RSrc = MRI.createVirtualRegister(&AMDGPU::SGPR_128RegClass); in buildRSRC()
5071 RSrcLo = MRI.createVirtualRegister(&AMDGPU::SReg_64RegClass); in buildRSRC()
5087 static Register buildAddr64RSrc(MachineIRBuilder &B, MachineRegisterInfo &MRI, in buildAddr64RSrc() argument
5093 return buildRSRC(B, MRI, 0, Hi_32(DefaultFormat), BasePtr); in buildAddr64RSrc()
5096 static Register buildOffsetSrc(MachineIRBuilder &B, MachineRegisterInfo &MRI, in buildOffsetSrc() argument
5102 return buildRSRC(B, MRI, -1, Hi_32(DefaultFormat), BasePtr); in buildOffsetSrc()
5113 std::tie(PtrBase, Offset) = getPtrBaseWithConstantOffset(Src, *MRI); in parseMUBUFAddress()
5120 = getOpcodeDef(TargetOpcode::G_PTR_ADD, Data.N0, *MRI)) { in parseMUBUFAddress()
5129 Data.N2 = getDefIgnoringCopies(Data.N2, *MRI)->getOperand(0).getReg(); in parseMUBUFAddress()
5130 Data.N3 = getDefIgnoringCopies(Data.N3, *MRI)->getOperand(0).getReg(); in parseMUBUFAddress()
5143 const RegisterBank *N0Bank = RBI.getRegBank(Addr.N0, *MRI, TRI); in shouldUseAddr64()
5156 SOffset = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in splitIllegalMUBUFOffset()
5184 if (RBI.getRegBank(N2, *MRI, TRI)->getID() == AMDGPU::VGPRRegBankID) { in selectMUBUFAddr64Impl()
5186 if (RBI.getRegBank(N3, *MRI, TRI)->getID() == AMDGPU::VGPRRegBankID) { in selectMUBUFAddr64Impl()
5199 } else if (RBI.getRegBank(N0, *MRI, TRI)->getID() == AMDGPU::VGPRRegBankID) { in selectMUBUFAddr64Impl()
5209 RSrcReg = buildAddr64RSrc(B, *MRI, TII, SRDPtr); in selectMUBUFAddr64Impl()
5234 RSrcReg = buildOffsetSrc(B, *MRI, TII, SRDPtr); in selectMUBUFOffsetImpl()
5308 if (STI.hasRestrictedSOffset() && mi_match(SOffset, *MRI, m_ZeroInt())) in selectBUFSOffset()
5316 getConstantZext32Val(Register Reg, const MachineRegisterInfo &MRI) { in getConstantZext32Val() argument
5318 std::optional<int64_t> OffsetVal = getIConstantVRegSExtVal(Reg, MRI); in getConstantZext32Val()
5326 std::optional<uint64_t> OffsetVal = getConstantZext32Val(Root.getReg(), *MRI); in selectSMRDBufferImm()
5342 std::optional<uint64_t> OffsetVal = getConstantZext32Val(Root.getReg(), *MRI); in selectSMRDBufferImm32()
5361 *MRI, Root.getReg(), KB, /*CheckNUW*/ true); in selectSMRDBufferSgprImm()
5370 assert(MRI->getType(SOffset) == LLT::scalar(32)); in selectSMRDBufferSgprImm()
5377 static MachineInstr *stripBitCast(MachineInstr *MI, MachineRegisterInfo &MRI) { in stripBitCast() argument
5379 return getDefIgnoringCopies(MI->getOperand(1).getReg(), MRI); in stripBitCast()
5386 MachineRegisterInfo &MRI) { in isExtractHiElt() argument
5387 Inst = stripBitCast(Inst, MRI); in isExtractHiElt()
5393 getDefIgnoringCopies(Inst->getOperand(1).getReg(), MRI); in isExtractHiElt()
5394 TruncOp = stripBitCast(TruncOp, MRI); in isExtractHiElt()
5399 TruncOp->getOperand(2).getReg(), MRI); in isExtractHiElt()
5402 getDefIgnoringCopies(TruncOp->getOperand(1).getReg(), MRI); in isExtractHiElt()
5403 return stripBitCast(SrlOp, MRI); in isExtractHiElt()
5412 assert(MRI.getType(TruncOp->getOperand(0).getReg()) == in isExtractHiElt()
5420 getDefIgnoringCopies(TruncOp->getOperand(1).getReg(), MRI); in isExtractHiElt()
5421 return stripBitCast(LHS, MRI); in isExtractHiElt()
5437 MachineInstr *MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3PMadMixModsImpl()
5441 MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3PMadMixModsImpl()
5443 assert(MRI->getType(Src) == LLT::scalar(16)); in selectVOP3PMadMixModsImpl()
5450 MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3PMadMixModsImpl()
5459 MI = getDefIgnoringCopies(Src, *MRI); in selectVOP3PMadMixModsImpl()
5478 if (MachineInstr *ExtractHiEltMI = isExtractHiElt(MI, *MRI)) { in selectVOP3PMadMixModsImpl()
5545 *MRI); in selectSBarrierSignalIsfirst()
5586 getIConstantVRegSExtVal(BarOp.getReg(), *MRI); in selectNamedBarrierInst()
5593 TmpReg0 = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectNamedBarrierInst()
5608 Register TmpReg1 = MRI->createVirtualRegister(&AMDGPU::SReg_32RegClass); in selectNamedBarrierInst()
5649 *MRI); in selectSBarrierLeave()