Lines Matching defs:GR
435 SPIRVGlobalRegistry *GR) {
437 SPIRVType *BoolType = GR->getOrCreateSPIRVBoolType(MIRBuilder);
442 GR->getOrCreateSPIRVVectorType(BoolType, VectorElements, MIRBuilder);
444 cast<FixedVectorType>(GR->getTypeForSPIRVType(BoolType));
452 MIRBuilder.getMRI()->setRegClass(ResultRegister, GR->getRegClass(ResultType));
453 GR->assignSPIRVTypeToVReg(BoolType, ResultRegister, MIRBuilder.getMF());
462 SPIRVGlobalRegistry *GR) {
466 unsigned Bits = GR->getScalarOrVectorBitWidth(ReturnType);
468 TrueConst = GR->getOrCreateConsIntVector(AllOnes, MIRBuilder, ReturnType);
469 FalseConst = GR->getOrCreateConsIntVector(0, MIRBuilder, ReturnType);
471 TrueConst = GR->buildConstantInt(1, MIRBuilder, ReturnType);
472 FalseConst = GR->buildConstantInt(0, MIRBuilder, ReturnType);
483 SPIRVGlobalRegistry *GR, LLT LowLevelType,
486 DestinationReg = createVirtualRegister(BaseType, GR, MIRBuilder);
498 SPIRVGlobalRegistry *GR, SPIRV::BuiltIn::BuiltIn BuiltinValue, LLT LLType,
505 GR->getPointerSize()));
506 SPIRVType *PtrType = GR->getOrCreateSPIRVPointerType(
508 GR->assignSPIRVTypeToVReg(PtrType, NewRegister, MIRBuilder.getMF());
511 Register Variable = GR->buildGlobalVariable(
519 buildLoadInst(VariableType, Variable, MIRBuilder, GR, LLType, Reg);
530 SPIRVGlobalRegistry *GR,
571 SPIRVGlobalRegistry *GR) {
572 return GR->buildConstantInt(Val, MIRBuilder,
573 GR->getOrCreateSPIRVIntegerType(32, MIRBuilder));
579 SPIRVGlobalRegistry *GR,
591 return buildConstantIntReg32(Scope, MIRBuilder, GR);
595 SPIRVGlobalRegistry *GR) {
598 SPIRVType *SpvType = GR->getSPIRVTypeForVReg(Reg);
600 SpvType ? GR->getRegClass(SpvType) : &SPIRV::iIDRegClass);
606 SPIRVGlobalRegistry *GR) {
613 getMemSemanticsForStorageClass(GR->getPointerStorageClass(PtrRegister));
619 return buildConstantIntReg32(Semantics, MIRBuilder, GR);
654 SPIRVGlobalRegistry *GR) {
655 Register TypeReg = GR->getSPIRVTypeID(Call->ReturnType);
666 : buildConstantIntReg32(SPIRV::Scope::Device, MIRBuilder, GR);
674 getMemSemanticsForStorageClass(GR->getPointerStorageClass(PtrRegister));
675 MemSemanticsReg = buildConstantIntReg32(Semantics, MIRBuilder, GR);
690 SPIRVGlobalRegistry *GR) {
695 buildConstantIntReg32(SPIRV::Scope::Device, MIRBuilder, GR);
699 getMemSemanticsForStorageClass(GR->getPointerStorageClass(PtrRegister));
700 Register MemSemanticsReg = buildConstantIntReg32(Semantics, MIRBuilder, GR);
712 unsigned Opcode, MachineIRBuilder &MIRBuilder, SPIRVGlobalRegistry *GR) {
715 GR->getSPIRVTypeID(Call->ReturnType));
723 SPIRVType *SpvDesiredTy = GR->getSPIRVTypeForVReg(Desired);
726 assert(GR->getSPIRVTypeForVReg(ObjectPtr)->getOpcode() ==
728 unsigned ExpectedType = GR->getSPIRVTypeForVReg(ExpectedArg)->getOpcode();
732 assert(GR->isScalarOfType(Desired, SPIRV::OpTypeInt));
734 SPIRVType *SpvObjectPtrTy = GR->getSPIRVTypeForVReg(ObjectPtr);
765 MemSemEqualReg = buildConstantIntReg32(MemSemEqual, MIRBuilder, GR);
767 MemSemUnequalReg = buildConstantIntReg32(MemSemUnequal, MIRBuilder, GR);
781 ScopeReg = buildConstantIntReg32(Scope, MIRBuilder, GR);
786 GR, LLT::scalar(64));
791 MRI->setRegClass(Tmp, GR->getRegClass(SpvDesiredTy));
792 GR->assignSPIRVTypeToVReg(SpvDesiredTy, Tmp, MIRBuilder.getMF());
794 SPIRVType *IntTy = GR->getOrCreateSPIRVIntegerType(32, MIRBuilder);
797 .addUse(GR->getSPIRVTypeID(IntTy))
814 SPIRVGlobalRegistry *GR) {
817 GR->getSPIRVTypeID(Call->ReturnType));
826 MIRBuilder, GR, MRI);
833 Semantics, MIRBuilder, GR);
835 Register ValueTypeReg = GR->getSPIRVTypeID(Call->ReturnType);
846 MRI->setRegClass(NegValueReg, GR->getRegClass(Call->ReturnType));
847 GR->assignSPIRVTypeToVReg(Call->ReturnType, NegValueReg,
852 insertAssignInstr(NegValueReg, nullptr, Call->ReturnType, GR, MIRBuilder,
871 SPIRVGlobalRegistry *GR) {
880 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
892 SPIRVGlobalRegistry *GR) {
894 Register TypeReg = GR->getSPIRVTypeID(Call->ReturnType);
905 Semantics, MIRBuilder, GR);
915 buildScopeReg(ScopeRegister, SPIRV::Scope::Device, MIRBuilder, GR, MRI);
929 SPIRVGlobalRegistry *GR) {
972 : buildConstantIntReg32(MemSemantics, MIRBuilder, GR);
994 ScopeReg = buildConstantIntReg32(Scope, MIRBuilder, GR);
998 MIB.addUse(buildConstantIntReg32(MemScope, MIRBuilder, GR));
1034 SPIRVGlobalRegistry *GR) {
1044 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1055 SPIRVGlobalRegistry *GR) {
1064 buildBoolRegister(MIRBuilder, Call->ReturnType, GR);
1069 .addUse(GR->getSPIRVTypeID(RelationType));
1076 Call->ReturnType, GR);
1081 SPIRVGlobalRegistry *GR) {
1090 GR->getSPIRVTypeID(Call->ReturnType));
1102 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1112 SPIRVType *BoolType = GR->getOrCreateSPIRVBoolType(MIRBuilder);
1114 SPIRVType *BoolRegType = GR->getSPIRVTypeForVReg(BoolReg);
1120 Arg0 = GR->buildConstantInt(getIConstVal(BoolReg, MRI), MIRBuilder,
1126 GR->assignSPIRVTypeToVReg(BoolType, Arg0, MIRBuilder.getMF());
1128 GR->buildConstantInt(0, MIRBuilder, BoolRegType));
1129 insertAssignInstr(Arg0, nullptr, BoolType, GR, MIRBuilder,
1150 buildBoolRegister(MIRBuilder, Call->ReturnType, GR);
1154 Register ScopeRegister = buildConstantIntReg32(Scope, MIRBuilder, GR);
1165 SPIRVType *ElemType = GR->getSPIRVTypeForVReg(ElemReg);
1173 GR->getOrCreateSPIRVVectorType(ElemType, VecLen, MIRBuilder);
1174 GR->assignSPIRVTypeToVReg(VecType, VecReg, MIRBuilder.getMF());
1179 setRegClassIfNull(Call->Arguments[i], MRI, GR);
1181 insertAssignInstr(VecReg, nullptr, VecType, GR, MIRBuilder,
1188 .addUse(GR->getSPIRVTypeID(GroupResultType))
1195 setRegClassIfNull(Call->Arguments[0], MRI, GR);
1206 Call->ReturnType, GR);
1212 SPIRVGlobalRegistry *GR) {
1239 IsSet ? GR->getSPIRVTypeID(Call->ReturnType)
1245 if (SPIRVType *Arg0Type = GR->getSPIRVTypeForVReg(Call->Arguments[0])) {
1278 .addUse(GR->getSPIRVTypeID(Call->ReturnType));
1286 SPIRVGlobalRegistry *GR) {
1320 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1330 SPIRVGlobalRegistry *GR) {
1349 Register ScopeReg = buildConstantIntReg32(ScopeArg, MIRBuilder, GR);
1353 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1387 SPIRVGlobalRegistry *GR,
1392 const unsigned PointerSize = GR->getPointerSize();
1394 GR->getOrCreateSPIRVIntegerType(PointerSize, MIRBuilder);
1412 GR->assignSPIRVTypeToVReg(PointerSizeType, DefaultReg,
1417 GR->buildConstantInt(DefaultValue, MIRBuilder, PointerSizeType);
1421 GR->getOrCreateSPIRVVectorType(PointerSizeType, 3, MIRBuilder);
1423 buildBuiltinVariableLoad(MIRBuilder, Vec3Ty, GR, BuiltinValue,
1430 GR->assignSPIRVTypeToVReg(PointerSizeType, Extracted, MIRBuilder.getMF());
1440 insertAssignInstr(Extracted, nullptr, PointerSizeType, GR, MIRBuilder,
1443 auto IndexType = GR->getSPIRVTypeForVReg(IndexRegister);
1444 auto BoolType = GR->getOrCreateSPIRVBoolType(MIRBuilder);
1449 GR->assignSPIRVTypeToVReg(BoolType, CompareRegister, MIRBuilder.getMF());
1453 GR->buildConstantInt(3, MIRBuilder, IndexType));
1458 GR->buildConstantInt(DefaultValue, MIRBuilder, PointerSizeType);
1466 GR->assignSPIRVTypeToVReg(PointerSizeType, SelectionResult,
1485 SPIRVGlobalRegistry *GR) {
1492 return genWorkgroupQuery(Call, MIRBuilder, GR, Value, 0);
1495 unsigned BitWidth = GR->getScalarOrVectorBitWidth(Call->ReturnType);
1503 return buildBuiltinVariableLoad(MIRBuilder, Call->ReturnType, GR, Value,
1509 SPIRVGlobalRegistry *GR) {
1519 return buildAtomicLoadInst(Call, MIRBuilder, GR);
1521 return buildAtomicStoreInst(Call, MIRBuilder, GR);
1525 GR);
1532 return buildAtomicRMWInst(Call, Opcode, MIRBuilder, GR);
1534 return buildBarrierInst(Call, SPIRV::OpMemoryBarrier, MIRBuilder, GR);
1537 return buildAtomicFlagInst(Call, Opcode, MIRBuilder, GR);
1541 GR->getSPIRVTypeID(Call->ReturnType));
1548 SPIRVGlobalRegistry *GR) {
1557 return buildAtomicFloatingRMWInst(Call, Opcode, MIRBuilder, GR);
1565 SPIRVGlobalRegistry *GR) {
1571 return buildBarrierInst(Call, Opcode, MIRBuilder, GR);
1584 SPIRVGlobalRegistry *GR) {
1587 GR->getSPIRVTypeID(Call->ReturnType));
1588 unsigned Opcode = GR->getSPIRVTypeForVReg(Call->Arguments[0])->getOpcode();
1593 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1601 SPIRVGlobalRegistry *GR) {
1608 LLT LLType = LLT::scalar(GR->getScalarOrVectorBitWidth(Call->ReturnType));
1611 MIRBuilder, Call->ReturnType, GR, Value, LLType, Call->ReturnRegister,
1623 SPIRVGlobalRegistry *GR) {
1629 SPIRVType *PtrRetType = GR->getSPIRVTypeForVReg(SRetReg);
1630 SPIRVType *RetType = GR->getPointeeType(PtrRetType);
1637 SPIRVType *OpType1 = GR->getSPIRVTypeForVReg(Call->Arguments[1]);
1638 SPIRVType *OpType2 = GR->getSPIRVTypeForVReg(Call->Arguments[2]);
1660 GR->assignSPIRVTypeToVReg(RetType, ResReg, MIRBuilder.getMF());
1663 .addUse(GR->getSPIRVTypeID(RetType))
1672 SPIRVGlobalRegistry *GR) {
1679 return genWorkgroupQuery(Call, MIRBuilder, GR, Value, IsDefault ? 1 : 0);
1684 SPIRVGlobalRegistry *GR) {
1697 SPIRVType *ImgType = GR->getSPIRVTypeForVReg(Call->Arguments[0]);
1705 SPIRVType *IntTy = GR->getOrCreateSPIRVIntegerType(32, MIRBuilder);
1706 QueryResultType = GR->getOrCreateSPIRVVectorType(
1708 GR->assignSPIRVTypeToVReg(QueryResultType, QueryResult, MIRBuilder.getMF());
1715 .addUse(GR->getSPIRVTypeID(QueryResultType))
1718 MIB.addUse(buildConstantIntReg32(0, MIRBuilder, GR)); // Lod id.
1727 Register TypeReg = GR->getSPIRVTypeID(Call->ReturnType);
1732 (NewType = GR->getSPIRVTypeForVReg(NewTypeReg)) != nullptr)
1741 insertAssignInstr(Call->ReturnRegister, nullptr, NewType, GR, MIRBuilder,
1747 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1758 SPIRVGlobalRegistry *GR) {
1769 GR->getSPIRVTypeForVReg(Image)->getOperand(2).getImm());
1788 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1828 SPIRVGlobalRegistry *GR) {
1836 if (!GR->isScalarOfType(Sampler, SPIRV::OpTypeSampler) &&
1839 Sampler = GR->buildConstantSampler(
1843 GR->getSPIRVTypeForVReg(Sampler));
1845 SPIRVType *ImageType = GR->getSPIRVTypeForVReg(Image);
1847 GR->getOrCreateOpTypeSampledImage(ImageType, MIRBuilder);
1852 .addUse(GR->getSPIRVTypeID(SampledImageType))
1856 Register Lod = GR->buildConstantFP(APFloat::getZero(APFloat::IEEEsingle()),
1861 GR->getOrCreateSPIRVVectorType(Call->ReturnType, 4, MIRBuilder);
1863 MRI->createGenericVirtualRegister(GR->getRegType(TempType));
1864 MRI->setRegClass(TempRegister, GR->getRegClass(TempType));
1865 GR->assignSPIRVTypeToVReg(TempType, TempRegister, MIRBuilder.getMF());
1868 .addUse(GR->getSPIRVTypeID(TempType))
1875 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1881 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1890 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1898 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
1907 SPIRVGlobalRegistry *GR) {
1918 SPIRVGlobalRegistry *GR) {
1924 Register Sampler = GR->buildConstantSampler(
1932 SPIRVType *ImageType = GR->getSPIRVTypeForVReg(Image);
1934 GR->getOrCreateOpTypeSampledImage(ImageType, MIRBuilder);
1941 .addUse(GR->getSPIRVTypeID(SampledImageType))
1956 : GR->getOrCreateSPIRVTypeByName(ReturnType, MIRBuilder);
1964 .addUse(GR->getSPIRVTypeID(Type))
1983 SPIRVGlobalRegistry *GR) {
1985 GR->getSPIRVTypeID(Call->ReturnType));
1990 SPIRVGlobalRegistry *GR) {
2039 Register TypeReg = GR->getSPIRVTypeID(Call->ReturnType);
2041 SPIRVType *CoopMatrType = GR->getSPIRVTypeForVReg(Call->Arguments[0]);
2056 SPIRVGlobalRegistry *GR) {
2087 .addUse(GR->getSPIRVTypeID(Call->ReturnType));
2100 .addUse(GR->getSPIRVTypeID(Call->ReturnType));
2112 SPIRVGlobalRegistry *GR) {
2114 SPIRVType *PtrType = GR->getSPIRVTypeForVReg(Call->Arguments[0]);
2118 SPIRVType *StructType = GR->getSPIRVTypeForVReg(TypeReg);
2121 GR->assignSPIRVTypeToVReg(StructType, TmpReg, MF);
2132 SPIRVType *SpvTy = GR->getSPIRVTypeForVReg(GlobalWorkSize);
2140 unsigned BitWidth = GR->getPointerSize() == 64 ? 64 : 32;
2143 SPIRVType *SpvFieldTy = GR->getOrCreateSPIRVType(FieldTy, MIRBuilder);
2145 GR->assignSPIRVTypeToVReg(SpvFieldTy, GlobalWorkSize, MF);
2148 .addUse(GR->getSPIRVTypeID(SpvFieldTy))
2152 Const = GR->getOrCreateConstIntArray(0, Size, *MIRBuilder.getInsertPt(),
2155 Const = GR->buildConstantInt(0, MIRBuilder, SpvTy);
2177 SPIRVGlobalRegistry *GR) {
2181 return GR->getOrCreateSPIRVType(PtrType, MIRBuilder);
2186 SPIRVGlobalRegistry *GR) {
2191 const SPIRVType *Int32Ty = GR->getOrCreateSPIRVIntegerType(32, MIRBuilder);
2210 const LLT LLType = LLT::pointer(SC, GR->getPointerSize());
2211 const SPIRVType *PointerSizeTy = GR->getOrCreateSPIRVPointerType(
2216 GR->assignSPIRVTypeToVReg(PointerSizeTy, Reg, MIRBuilder.getMF());
2222 .addUse(buildConstantIntReg32(0, MIRBuilder, GR)) // Indices.
2223 .addUse(buildConstantIntReg32(I, MIRBuilder, GR));
2231 .addUse(GR->getSPIRVTypeID(Int32Ty));
2240 MIB.addUse(buildConstantIntReg32(0, MIRBuilder, GR)); // Dummy num events.
2241 Register NullPtr = GR->getOrCreateConstNullPtr(
2242 MIRBuilder, getOrCreateSPIRVDeviceEventPointer(MIRBuilder, GR));
2259 MIB.addUse(buildConstantIntReg32(DL.getTypeStoreSize(PType), MIRBuilder, GR));
2262 MIRBuilder, GR));
2271 SPIRVGlobalRegistry *GR) {
2285 .addUse(GR->getSPIRVTypeID(Call->ReturnType));
2289 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
2301 return buildNDRange(Call, MIRBuilder, GR);
2303 return buildEnqueueKernel(Call, MIRBuilder, GR);
2311 SPIRVGlobalRegistry *GR) {
2318 Register TypeReg = GR->getSPIRVTypeID(Call->ReturnType);
2323 auto Scope = buildConstantIntReg32(SPIRV::Scope::Workgroup, MIRBuilder, GR);
2330 : GR->getOrCreateSPIRVTypeByName("spirv.Event", MIRBuilder);
2331 Register TypeReg = GR->getSPIRVTypeID(NewType ? NewType : Call->ReturnType);
2343 : buildConstantIntReg32(1, MIRBuilder, GR))
2346 insertAssignInstr(Call->ReturnRegister, nullptr, NewType, GR, MIRBuilder,
2363 SPIRVGlobalRegistry *GR) {
2373 GR->getSPIRVTypeID(Call->ReturnType));
2387 if (GR->isScalarOrVectorOfType(Call->Arguments[0], SPIRV::OpTypeInt)) {
2389 if (GR->isScalarOrVectorOfType(Call->ReturnRegister, SPIRV::OpTypeInt)) {
2397 } else if (GR->isScalarOrVectorOfType(Call->ReturnRegister,
2407 GR->getScalarOrVectorComponentCount(Call->Arguments[0]) ==
2408 GR->getScalarOrVectorComponentCount(Call->ReturnRegister);
2416 } else if (GR->isScalarOrVectorOfType(Call->Arguments[0],
2419 if (GR->isScalarOrVectorOfType(Call->ReturnRegister, SPIRV::OpTypeInt)) {
2428 GR->getScalarOrVectorComponentCount(Call->Arguments[0]) ==
2429 GR->getScalarOrVectorComponentCount(Call->ReturnRegister);
2435 } else if (GR->isScalarOrVectorOfType(Call->ReturnRegister,
2460 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
2467 SPIRVGlobalRegistry *GR) {
2476 .addUse(GR->getSPIRVTypeID(Call->ReturnType))
2493 SPIRVGlobalRegistry *GR) {
2503 MIB.addUse(GR->getSPIRVTypeID(Call->ReturnType));
2599 SPIRVGlobalRegistry *GR) {
2603 SPIRVType *SpvType = GR->getSPIRVTypeForVReg(OrigRet);
2622 return generateExtInst(Call.get(), MIRBuilder, GR);
2624 return generateRelationalInst(Call.get(), MIRBuilder, GR);
2626 return generateGroupInst(Call.get(), MIRBuilder, GR);
2628 return generateBuiltinVar(Call.get(), MIRBuilder, GR);
2630 return generateAtomicInst(Call.get(), MIRBuilder, GR);
2632 return generateAtomicFloatingInst(Call.get(), MIRBuilder, GR);
2634 return generateBarrierInst(Call.get(), MIRBuilder, GR);
2638 return generateDotOrFMulInst(Call.get(), MIRBuilder, GR);
2640 return generateWaveInst(Call.get(), MIRBuilder, GR);
2642 return generateICarryBorrowInst(Call.get(), MIRBuilder, GR);
2644 return generateGetQueryInst(Call.get(), MIRBuilder, GR);
2646 return generateImageSizeQueryInst(Call.get(), MIRBuilder, GR);
2648 return generateImageMiscQueryInst(Call.get(), MIRBuilder, GR);
2650 return generateReadImageInst(DemangledCall, Call.get(), MIRBuilder, GR);
2652 return generateWriteImageInst(Call.get(), MIRBuilder, GR);
2654 return generateSampleImageInst(DemangledCall, Call.get(), MIRBuilder, GR);
2658 return generateConstructInst(Call.get(), MIRBuilder, GR);
2660 return generateSpecConstantInst(Call.get(), MIRBuilder, GR);
2662 return generateEnqueueInst(Call.get(), MIRBuilder, GR);
2664 return generateAsyncCopy(Call.get(), MIRBuilder, GR);
2666 return generateConvertInst(DemangledCall, Call.get(), MIRBuilder, GR);
2668 return generateVectorLoadStoreInst(Call.get(), MIRBuilder, GR);
2670 return generateLoadStoreInst(Call.get(), MIRBuilder, GR);
2672 return generateIntelSubgroupsInst(Call.get(), MIRBuilder, GR);
2674 return generateGroupUniformInst(Call.get(), MIRBuilder, GR);
2676 return generateKernelClockInst(Call.get(), MIRBuilder, GR);
2678 return generateCoopMatrInst(Call.get(), MIRBuilder, GR);
2792 SPIRVGlobalRegistry *GR) {
2795 return GR->getOrCreateOpTypeByOpcode(ExtensionType, MIRBuilder, Opcode);
2799 SPIRVGlobalRegistry *GR) {
2801 return GR->getOrCreateOpTypeSampler(MIRBuilder);
2806 SPIRVGlobalRegistry *GR) {
2810 return GR->getOrCreateOpTypePipe(MIRBuilder,
2817 SPIRVGlobalRegistry *GR) {
2823 GR->getOrCreateSPIRVType(ExtensionType->getTypeParameter(0), MIRBuilder);
2825 return GR->getOrCreateOpTypeCoopMatr(
2834 MachineIRBuilder &MIRBuilder, SPIRVGlobalRegistry *GR) {
2838 GR->getOrCreateSPIRVType(ExtensionType->getTypeParameter(0), MIRBuilder);
2853 return GR->getOrCreateOpTypeImage(
2864 SPIRVGlobalRegistry *GR) {
2866 OpaqueType, SPIRV::AccessQualifier::ReadOnly, MIRBuilder, GR);
2868 return GR->getOrCreateOpTypeSampledImage(OpaqueImageType, MIRBuilder);
2924 SPIRVGlobalRegistry *GR) {
2955 TargetType = getImageType(BuiltinType, AccessQual, MIRBuilder, GR);
2958 TargetType = getPipeType(BuiltinType, MIRBuilder, GR);
2961 TargetType = GR->getOrCreateOpTypeDeviceEvent(MIRBuilder);
2964 TargetType = getSamplerType(MIRBuilder, GR);
2967 TargetType = getSampledImageType(BuiltinType, MIRBuilder, GR);
2970 TargetType = getCoopMatrType(BuiltinType, MIRBuilder, GR);
2974 getNonParameterizedType(BuiltinType, TypeRecord, MIRBuilder, GR);
2981 buildOpName(GR->getSPIRVTypeID(TargetType), Name, MIRBuilder);