reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/CodeGen/GlobalISel/ConstantFoldingMIRBuilder.h
   53               ConstantFoldBinOp(Opc, Src0.getReg(), Src1.getReg(), *getMRI()))
   64               ConstantFoldExtOp(Opc, Src0.getReg(), Src1.getImm(), *getMRI()))
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h
 1341     auto NegOne = buildConstant(Dst.getLLTTy(*getMRI()), -1);
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp
  161                                                 SrcOps[1].getReg(), *getMRI()))
  172             ConstantFoldExtOp(Opc, Src0.getReg(), Src1.getImm(), *getMRI()))
  190   GISelInstProfileBuilder ProfBuilder(ID, *getMRI());
  211   LLT Ty = Res.getLLTTy(*getMRI());
  216   GISelInstProfileBuilder ProfBuilder(ID, *getMRI());
  238   LLT Ty = Res.getLLTTy(*getMRI());
  243   GISelInstProfileBuilder ProfBuilder(ID, *getMRI());
lib/CodeGen/GlobalISel/CallLowering.cpp
  131   MachineRegisterInfo *MRI = MIRBuilder.getMRI();
  233                 MIRBuilder.getMRI()->createGenericVirtualRegister(NewLLT);
  324             MIRBuilder.getMRI()->createGenericVirtualRegister(VATy);
lib/CodeGen/GlobalISel/CombinerHelper.cpp
  892   MachineRegisterInfo &MRI = *MIB.getMRI();
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp
  174   assert(Res.getLLTTy(*getMRI()).isPointer() && "expected ptr dst type");
  176   Res.addDefToMIB(*getMRI(), MIB);
  184   assert(Res.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  186   Res.addDefToMIB(*getMRI(), MIB);
  193   assert(Res.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  194   assert(Res.getLLTTy(*getMRI()).getAddressSpace() ==
  199   Res.addDefToMIB(*getMRI(), MIB);
  225   assert(Res.getLLTTy(*getMRI()).isPointer() &&
  226          Res.getLLTTy(*getMRI()) == Op0.getLLTTy(*getMRI()) && "type mismatch");
  226          Res.getLLTTy(*getMRI()) == Op0.getLLTTy(*getMRI()) && "type mismatch");
  227   assert(Op1.getLLTTy(*getMRI()).isScalar() && "invalid offset type");
  243   Res = getMRI()->createGenericVirtualRegister(getMRI()->getType(Op0));
  243   Res = getMRI()->createGenericVirtualRegister(getMRI()->getType(Op0));
  251   assert(Res.getLLTTy(*getMRI()).isPointer() &&
  252          Res.getLLTTy(*getMRI()) == Op0.getLLTTy(*getMRI()) && "type mismatch");
  252          Res.getLLTTy(*getMRI()) == Op0.getLLTTy(*getMRI()) && "type mismatch");
  255   Res.addDefToMIB(*getMRI(), MIB);
  266   assert(getMRI()->getType(Tgt).isPointer() && "invalid branch destination");
  273   assert(getMRI()->getType(TablePtr).isPointer() &&
  288   LLT Ty = Res.getLLTTy(*getMRI());
  295     .addDef(getMRI()->createGenericVirtualRegister(EltTy))
  301   Res.addDefToMIB(*getMRI(), Const);
  309                                Res.getLLTTy(*getMRI()).getScalarSizeInBits());
  316   LLT Ty = Res.getLLTTy(*getMRI());
  327     .addDef(getMRI()->createGenericVirtualRegister(EltTy))
  334   Res.addDefToMIB(*getMRI(), Const);
  347   LLT DstTy = Res.getLLTTy(*getMRI());
  363   assert(getMRI()->getType(Tst).isScalar() && "invalid operand type");
  378   assert(Res.getLLTTy(*getMRI()).isValid() && "invalid operand type");
  379   assert(Addr.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  382   Res.addDefToMIB(*getMRI(), MIB);
  391   assert(Val.getLLTTy(*getMRI()).isValid() && "invalid operand type");
  392   assert(Addr.getLLTTy(*getMRI()).isPointer() && "invalid operand type");
  447   unsigned ExtOp = getBoolExtOp(getMRI()->getType(Op.getReg()).isVector(), IsFP);
  457   assert(Res.getLLTTy(*getMRI()).isScalar() ||
  458          Res.getLLTTy(*getMRI()).isVector());
  459   assert(Res.getLLTTy(*getMRI()).isScalar() ==
  460          Op.getLLTTy(*getMRI()).isScalar());
  463   if (Res.getLLTTy(*getMRI()).getSizeInBits() >
  464       Op.getLLTTy(*getMRI()).getSizeInBits())
  466   else if (Res.getLLTTy(*getMRI()).getSizeInBits() <
  467            Op.getLLTTy(*getMRI()).getSizeInBits())
  470     assert(Res.getLLTTy(*getMRI()) == Op.getLLTTy(*getMRI()));
  470     assert(Res.getLLTTy(*getMRI()) == Op.getLLTTy(*getMRI()));
  492   LLT SrcTy = Src.getLLTTy(*getMRI());
  493   LLT DstTy = Dst.getLLTTy(*getMRI());
  513   LLT SrcTy = Src.getLLTTy(*getMRI());
  514   LLT DstTy = Dst.getLLTTy(*getMRI());
  529   Dst.addDefToMIB(*getMRI(), Extract);
  543   assert(getMRI()->getType(Res).isValid() && "invalid operand type");
  545     assert(getMRI()->getType(Op).isValid() && "invalid operand type");
  548   LLT ResTy = getMRI()->getType(Res);
  549   LLT OpTy = getMRI()->getType(Ops[0]);
  553     if (getMRI()->getType(Ops[i]) != OpTy || Indices[i] != i * OpSize) {
  564   Register ResIn = getMRI()->createGenericVirtualRegister(ResTy);
  570                           : getMRI()->createGenericVirtualRegister(ResTy);
  602   unsigned NumReg = Op.getLLTTy(*getMRI()).getSizeInBits() / Res.getSizeInBits();
  605     TmpVec.push_back(getMRI()->createGenericVirtualRegister(Res));
  630   SmallVector<SrcOp, 8> TmpVec(Res.getLLTTy(*getMRI()).getNumElements(), Src);
  655   assert(Index + getMRI()->getType(Op).getSizeInBits() <=
  656              getMRI()->getType(Res).getSizeInBits() &&
  659   if (getMRI()->getType(Res).getSizeInBits() ==
  660       getMRI()->getType(Op).getSizeInBits()) {
  690     Result.addDefToMIB(*getMRI(), MIB);
  747   LLT OldValResTy = getMRI()->getType(OldValRes);
  748   LLT SuccessResTy = getMRI()->getType(SuccessRes);
  749   LLT AddrTy = getMRI()->getType(Addr);
  750   LLT CmpValTy = getMRI()->getType(CmpVal);
  751   LLT NewValTy = getMRI()->getType(NewVal);
  775   LLT OldValResTy = getMRI()->getType(OldValRes);
  776   LLT AddrTy = getMRI()->getType(Addr);
  777   LLT CmpValTy = getMRI()->getType(CmpVal);
  778   LLT NewValTy = getMRI()->getType(NewVal);
  801   LLT OldValResTy = OldValRes.getLLTTy(*getMRI());
  802   LLT AddrTy = Addr.getLLTTy(*getMRI());
  803   LLT ValTy = Val.getLLTTy(*getMRI());
  812   OldValRes.addDefToMIB(*getMRI(), MIB);
  912   assert(getMRI()->getType(Res).isPointer() && "invalid res type");
  964         DstOps[0].getLLTTy(*getMRI()), SrcOps[0].getLLTTy(*getMRI()),
  964         DstOps[0].getLLTTy(*getMRI()), SrcOps[0].getLLTTy(*getMRI()),
  965         SrcOps[1].getLLTTy(*getMRI()), SrcOps[2].getLLTTy(*getMRI()));
  965         SrcOps[1].getLLTTy(*getMRI()), SrcOps[2].getLLTTy(*getMRI()));
  985     validateBinaryOp(DstOps[0].getLLTTy(*getMRI()),
  986                      SrcOps[0].getLLTTy(*getMRI()),
  987                      SrcOps[1].getLLTTy(*getMRI()));
  995     validateShiftOp(DstOps[0].getLLTTy(*getMRI()),
  996                     SrcOps[0].getLLTTy(*getMRI()),
  997                     SrcOps[1].getLLTTy(*getMRI()));
 1005     validateTruncExt(DstOps[0].getLLTTy(*getMRI()),
 1006                      SrcOps[0].getLLTTy(*getMRI()), true);
 1012     validateTruncExt(DstOps[0].getLLTTy(*getMRI()),
 1013                      SrcOps[0].getLLTTy(*getMRI()), false);
 1034     assert(SrcOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
 1034     assert(SrcOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
 1037       LLT Op0Ty = SrcOps[1].getLLTTy(*getMRI());
 1038       LLT DstTy = DstOps[0].getLLTTy(*getMRI());
 1052                          return Op.getLLTTy(*getMRI()) ==
 1053                                 DstOps[0].getLLTTy(*getMRI());
 1056     assert(DstOps.size() * DstOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1057                SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() &&
 1066                          return Op.getLLTTy(*getMRI()) ==
 1067                                 SrcOps[0].getLLTTy(*getMRI());
 1070     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1071                DstOps[0].getLLTTy(*getMRI()).getSizeInBits() &&
 1075     if (DstOps[0].getLLTTy(*getMRI()).isVector()) {
 1076       if (SrcOps[0].getLLTTy(*getMRI()).isVector())
 1085     assert(SrcOps[0].getLLTTy(*getMRI()).isVector() && "Invalid operand type");
 1086     assert((DstOps[0].getLLTTy(*getMRI()).isScalar() ||
 1087             DstOps[0].getLLTTy(*getMRI()).isPointer()) &&
 1089     assert(SrcOps[1].getLLTTy(*getMRI()).isScalar() && "Invalid operand type");
 1090     assert(SrcOps[0].getLLTTy(*getMRI()).getElementType() ==
 1091                DstOps[0].getLLTTy(*getMRI()) &&
 1098     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1099            SrcOps[0].getLLTTy(*getMRI()).isVector() && "Invalid operand type");
 1100     assert(DstOps[0].getLLTTy(*getMRI()).getElementType() ==
 1101                SrcOps[1].getLLTTy(*getMRI()) &&
 1103     assert(SrcOps[2].getLLTTy(*getMRI()).isScalar() && "Invalid index");
 1104     assert(DstOps[0].getLLTTy(*getMRI()).getNumElements() ==
 1105                SrcOps[0].getLLTTy(*getMRI()).getNumElements() &&
 1113     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1117                          return Op.getLLTTy(*getMRI()) ==
 1118                                 SrcOps[0].getLLTTy(*getMRI());
 1121     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1122                DstOps[0].getLLTTy(*getMRI()).getSizeInBits() &&
 1130     assert(DstOps[0].getLLTTy(*getMRI()).isVector() &&
 1134                          return Op.getLLTTy(*getMRI()) ==
 1135                                 SrcOps[0].getLLTTy(*getMRI());
 1138     if (SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1139         DstOps[0].getLLTTy(*getMRI()).getElementType().getSizeInBits())
 1149                          return (Op.getLLTTy(*getMRI()).isVector() &&
 1150                                  Op.getLLTTy(*getMRI()) ==
 1151                                      SrcOps[0].getLLTTy(*getMRI()));
 1154     assert(SrcOps.size() * SrcOps[0].getLLTTy(*getMRI()).getSizeInBits() ==
 1155                DstOps[0].getLLTTy(*getMRI()).getSizeInBits() &&
 1162     assert(DstOps[0].getLLTTy(*getMRI()).isScalar() && "Invalid operand");
 1163     assert((DstOps[0].getLLTTy(*getMRI()) == SrcOps[0].getLLTTy(*getMRI())) &&
 1163     assert((DstOps[0].getLLTTy(*getMRI()) == SrcOps[0].getLLTTy(*getMRI())) &&
 1164            (DstOps[0].getLLTTy(*getMRI()) == SrcOps[1].getLLTTy(*getMRI())) &&
 1164            (DstOps[0].getLLTTy(*getMRI()) == SrcOps[1].getLLTTy(*getMRI())) &&
 1166     assert(DstOps[1].getLLTTy(*getMRI()).isScalar() && "Invalid operand");
 1167     assert(DstOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
 1167     assert(DstOps[1].getLLTTy(*getMRI()) == SrcOps[2].getLLTTy(*getMRI()) &&
 1175     Op.addDefToMIB(*getMRI(), MIB);
lib/Target/AArch64/AArch64CallLowering.cpp
  113     MIRBuilder.getMRI()->addLiveIn(PhysReg);
lib/Target/AArch64/AArch64InstructionSelector.cpp
 2807   MachineRegisterInfo &MRI = *MIRBuilder.getMRI();
 3380   MachineRegisterInfo &MRI = *MIB.getMRI();
 3480   MachineRegisterInfo &MRI = *MIRBuilder.getMRI();
 3582   MachineRegisterInfo &MRI = *MIB.getMRI();
 3748   MachineRegisterInfo &MRI = *MIRBuilder.getMRI();
 4554   MachineRegisterInfo &MRI = *MIB.getMRI();
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp
 1616     B.getMRI()->createGenericVirtualRegister(ConstPtrTy);
 1627   B.getMRI()->setRegClass(PCReg, &AMDGPU::SReg_64RegClass);
 1794   MachineRegisterInfo &MRI = *B.getMRI();
lib/Target/AMDGPU/AMDGPURegisterBankInfo.cpp
  608   MachineRegisterInfo *MRI = B.getMRI();
 1195   std::tie(BaseReg, ImmOffset) = getBaseWithConstantOffset(*B.getMRI(),
 1251    MachineRegisterInfo &MRI = *B.getMRI();
lib/Target/ARM/ARMCallLowering.cpp
  409     MIRBuilder.getMRI()->addLiveIn(PhysReg);
lib/Target/Mips/MipsCallLowering.cpp
  109     MIRBuilder.getMRI()->addLiveIn(PhysReg);
lib/Target/Mips/MipsInstructionSelector.cpp
  151   Register LUiReg = B.getMRI()->createVirtualRegister(&Mips::GPR32RegClass);
lib/Target/X86/X86CallLowering.cpp
  307     MIRBuilder.getMRI()->addLiveIn(PhysReg);