36#define DEBUG_TYPE "spirv-module-analysis"
41 "SPIRV module analysis",
true,
true)
45 Func.getContext().diagnose(
51 unsigned DefaultVal = 0) {
52 if (MdNode && OpIndex < MdNode->getNumOperands()) {
61 SPIRV::Capability::Capability Cap) {
62 return Cap == (ST.isShader() ? SPIRV::Capability::Kernel
63 : SPIRV::Capability::Shader) ||
74 bool MinVerOK = SPIRVVersion.
empty() || SPIRVVersion >= ReqMinVer;
76 ReqMaxVer.
empty() || SPIRVVersion.
empty() || SPIRVVersion <= ReqMaxVer;
77 bool VerOK = MinVerOK && MaxVerOK;
81 if (VerOK && !ReqMinVer.
empty())
83 if (ReqCaps.
empty()) {
84 if (ReqExts.
empty()) {
86 return {
true, {}, {}, ReqMinVer, ReqMaxVer};
90 if (ReqCaps.
size() == 1) {
91 auto Cap = ReqCaps[0];
94 SPIRV::OperandCategory::CapabilityOperand, Cap));
95 return {
true, {Cap}, std::move(ReqExts), ReqMinVer, ReqMaxVer};
105 for (
auto Cap : ReqCaps)
108 for (
size_t i = 0, Sz = UseCaps.
size(); i < Sz; ++i) {
109 auto Cap = UseCaps[i];
112 SPIRV::OperandCategory::CapabilityOperand, Cap));
113 return {
true, {Cap}, std::move(ReqExts), ReqMinVer, ReqMaxVer};
122 if ((!ReqExts.
empty() || VerOK) &&
123 llvm::all_of(ReqExts, [&ST](
const SPIRV::Extension::Extension &Ext) {
124 return ST.canUseExtension(Ext);
127 return {
true, {}, std::move(ReqExts), ReqMinVer, ReqMaxVer};
133void SPIRVModuleAnalysisImpl::setBaseInfo(
const Module &M) {
137 MAI.RegisterAliasTable.clear();
138 MAI.InstrsToDelete.clear();
139 MAI.MBBNames.clear();
140 MAI.GlobalObjMap.clear();
141 MAI.GlobalVarList.clear();
142 MAI.ExtInstSetMap.clear();
143 MAI.InstrAuxDataRecords.clear();
144 MAI.DebugValueMIs.clear();
146 MAI.Reqs.initAvailableCapabilities(*ST);
149 if (
auto MemModel =
M.getNamedMetadata(
"spirv.MemoryModel")) {
150 auto MemMD = MemModel->getOperand(0);
151 MAI.Addr =
static_cast<SPIRV::AddressingModel::AddressingModel
>(
154 static_cast<SPIRV::MemoryModel::MemoryModel
>(
getMetadataUInt(MemMD, 1));
157 MAI.Mem = ST->isShader() ? SPIRV::MemoryModel::GLSL450
158 : SPIRV::MemoryModel::OpenCL;
159 if (MAI.Mem == SPIRV::MemoryModel::OpenCL) {
160 unsigned PtrSize = ST->getPointerSize();
161 MAI.Addr = PtrSize == 32 ? SPIRV::AddressingModel::Physical32
162 : PtrSize == 64 ? SPIRV::AddressingModel::Physical64
163 : SPIRV::AddressingModel::Logical;
166 MAI.Addr = SPIRV::AddressingModel::Logical;
171 if (
auto VerNode =
M.getNamedMetadata(
"opencl.ocl.version")) {
172 MAI.SrcLang = SPIRV::SourceLanguage::OpenCL_C;
175 assert(VerNode->getNumOperands() > 0 &&
"Invalid SPIR");
176 auto VersionMD = VerNode->getOperand(0);
182 (std::max(1U, MajorNum) * 100 + MinorNum) * 1000 + RevNum;
185 if (
auto *CxxVerNode =
M.getNamedMetadata(
"opencl.cxx.version")) {
186 assert(CxxVerNode->getNumOperands() > 0 &&
"Invalid SPIR");
187 auto *CxxMD = CxxVerNode->getOperand(0);
191 if ((MAI.SrcLangVersion == 200000 && CxxVer == 100000) ||
192 (MAI.SrcLangVersion == 300000 && CxxVer == 202100000)) {
193 MAI.SrcLang = SPIRV::SourceLanguage::CPP_for_OpenCL;
194 MAI.SrcLangVersion = CxxVer;
197 "opencl cxx version is not compatible with opencl c version!");
205 if (!ST->isShader()) {
206 MAI.SrcLang = SPIRV::SourceLanguage::OpenCL_CPP;
207 MAI.SrcLangVersion = 100000;
209 MAI.SrcLang = SPIRV::SourceLanguage::Unknown;
210 MAI.SrcLangVersion = 0;
214 if (
auto ExtNode =
M.getNamedMetadata(
"opencl.used.extensions")) {
215 for (
unsigned I = 0,
E = ExtNode->getNumOperands();
I !=
E; ++
I) {
216 MDNode *MD = ExtNode->getOperand(
I);
226 MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::MemoryModelOperand,
228 MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::SourceLanguageOperand,
230 MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::AddressingModelOperand,
233 if (MAI.Mem == SPIRV::MemoryModel::VulkanKHR)
234 MAI.Reqs.addExtension(SPIRV::Extension::SPV_KHR_vulkan_memory_model);
236 if (!ST->isShader()) {
238 MAI.ExtInstSetMap[
static_cast<unsigned>(
239 SPIRV::InstructionSet::OpenCL_std)] = MAI.getNextIDRegister();
250 if (
UseMI.getOpcode() != SPIRV::OpDecorate &&
251 UseMI.getOpcode() != SPIRV::OpMemberDecorate)
254 for (
unsigned I = 0;
I <
UseMI.getNumOperands(); ++
I) {
272 for (
unsigned i = 0; i <
MI.getNumOperands(); ++i) {
281 unsigned Opcode =
MI.getOpcode();
282 if ((Opcode == SPIRV::OpDecorate) && i >= 2) {
283 unsigned DecorationID =
MI.getOperand(1).getImm();
284 if (DecorationID != SPIRV::Decoration::FuncParamAttr &&
285 DecorationID != SPIRV::Decoration::UserSemantic &&
286 DecorationID != SPIRV::Decoration::CacheControlLoadINTEL &&
287 DecorationID != SPIRV::Decoration::CacheControlStoreINTEL)
293 if (!UseDefReg && MO.
isDef()) {
301 dbgs() <<
"Unexpectedly, no global id found for the operand ";
303 dbgs() <<
"\nInstruction: ";
330 case SPIRV::OpEnqueueKernel:
332 case SPIRV::OpGetKernelNDrangeSubGroupCount:
333 case SPIRV::OpGetKernelNDrangeMaxSubGroupSize:
335 case SPIRV::OpGetKernelWorkGroupSize:
336 case SPIRV::OpGetKernelPreferredWorkGroupSizeMultiple:
345 unsigned Opcode =
MI.getOpcode();
347 case SPIRV::OpTypeForwardPointer:
350 case SPIRV::OpVariable:
351 case SPIRV::OpUntypedVariableKHR:
352 return static_cast<SPIRV::StorageClass::StorageClass
>(
353 MI.getOperand(2).
getImm()) != SPIRV::StorageClass::Function;
354 case SPIRV::OpFunction:
355 case SPIRV::OpFunctionParameter:
358 if (GR->hasConstFunPtr() && Opcode == SPIRV::OpUndef) {
366 if (GR->getFunctionDefinitionByUse(&
MI.getOperand(0))) {
368 unsigned UseOp =
UseMI.getOpcode();
369 if (UseOp == SPIRV::OpConstantFunctionPointerINTEL ||
371 MAI.setSkipEmission(&
MI);
377 if (
UseMI.getOpcode() != SPIRV::OpConstantFunctionPointerINTEL)
383 MAI.setSkipEmission(&
MI);
387 return TII->isTypeDeclInstr(
MI) || TII->isConstantInstr(
MI) ||
388 TII->isInlineAsmDefInstr(
MI);
397void SPIRVModuleAnalysisImpl::visitFunPtrUse(
400 std::map<const Value *, unsigned> &GlobalToGReg,
402 const MachineOperand *OpFunDef = GR->getFunctionDefinitionByUse(FunPtrOp);
405 const MachineInstr *OpDefMI = OpFunDef->
getParent();
408 const MachineRegisterInfo &FunDefMRI = FunDefMF->
getRegInfo();
410 visitDecl(FunDefMRI, SignatureToGReg, GlobalToGReg, FunDefMF, *OpDefMI);
412 }
while (OpDefMI && (OpDefMI->
getOpcode() == SPIRV::OpFunction ||
413 OpDefMI->
getOpcode() == SPIRV::OpFunctionParameter));
415 MCRegister GlobalFunDefReg =
416 MAI.getRegisterAlias(FunDefMF, OpFunDef->
getReg());
418 "Function definition must refer to a global register");
419 MAI.setRegisterAlias(MF, OpReg, GlobalFunDefReg);
424void SPIRVModuleAnalysisImpl::visitDecl(
426 std::map<const Value *, unsigned> &GlobalToGReg,
const MachineFunction *MF,
428 unsigned Opcode =
MI.getOpcode();
431 for (
const MachineOperand &MO :
MI.operands()) {
432 if (!MO.isReg() || MO.isDef())
436 if (Opcode == SPIRV::OpConstantFunctionPointerINTEL &&
438 visitFunPtrUse(OpReg, &
MI.getOperand(2), SignatureToGReg, GlobalToGReg,
443 if (MAI.hasRegisterAlias(MF, MO.getReg()))
447 if (isDeclSection(
MRI, *OpDefMI))
448 visitDecl(
MRI, SignatureToGReg, GlobalToGReg, MF, *OpDefMI);
454 dbgs() <<
"Unexpectedly, no unique definition for the operand ";
456 dbgs() <<
"\nInstruction: ";
461 "No unique definition is found for the virtual register");
465 bool IsFunDef =
false;
466 if (TII->isSpecConstantInstr(
MI)) {
467 GReg = MAI.getNextIDRegister();
469 }
else if (Opcode == SPIRV::OpFunction ||
470 Opcode == SPIRV::OpFunctionParameter) {
471 GReg = handleFunctionOrParameter(MF,
MI, GlobalToGReg, IsFunDef);
472 }
else if (Opcode == SPIRV::OpTypeStruct ||
473 Opcode == SPIRV::OpConstantComposite) {
474 GReg = handleTypeDeclOrConstant(
MI, SignatureToGReg);
475 const MachineInstr *NextInstr =
MI.getNextNode();
477 ((Opcode == SPIRV::OpTypeStruct &&
478 NextInstr->
getOpcode() == SPIRV::OpTypeStructContinuedINTEL) ||
479 (Opcode == SPIRV::OpConstantComposite &&
481 SPIRV::OpConstantCompositeContinuedINTEL))) {
482 MCRegister Tmp = handleTypeDeclOrConstant(*NextInstr, SignatureToGReg);
484 MAI.setSkipEmission(NextInstr);
487 }
else if (TII->isTypeDeclInstr(
MI) || TII->isConstantInstr(
MI) ||
488 TII->isInlineAsmDefInstr(
MI)) {
489 GReg = handleTypeDeclOrConstant(
MI, SignatureToGReg);
490 }
else if (Opcode == SPIRV::OpVariable ||
491 Opcode == SPIRV::OpUntypedVariableKHR) {
492 GReg = handleVariable(MF,
MI, GlobalToGReg);
495 dbgs() <<
"\nInstruction: ";
501 MAI.setRegisterAlias(MF,
MI.getOperand(0).getReg(), GReg);
503 MAI.setSkipEmission(&
MI);
506MCRegister SPIRVModuleAnalysisImpl::handleFunctionOrParameter(
508 std::map<const Value *, unsigned> &GlobalToGReg,
bool &IsFunDef) {
509 const Value *GObj = GR->getGlobalObject(MF,
MI.getOperand(0).getReg());
510 assert(GObj &&
"Unregistered global definition");
514 assert(
F &&
"Expected a reference to a function or an argument");
515 IsFunDef = !
F->isDeclaration();
516 auto [It,
Inserted] = GlobalToGReg.try_emplace(GObj);
519 MCRegister GReg = MAI.getNextIDRegister();
526MCRegister SPIRVModuleAnalysisImpl::handleTypeDeclOrConstant(
529 auto [It,
Inserted] = SignatureToGReg.try_emplace(MISign);
532 MCRegister GReg = MAI.getNextIDRegister();
538MCRegister SPIRVModuleAnalysisImpl::handleVariable(
540 std::map<const Value *, unsigned> &GlobalToGReg) {
541 MAI.GlobalVarList.push_back(&
MI);
542 const Value *GObj = GR->getGlobalObject(MF,
MI.getOperand(0).getReg());
543 assert(GObj &&
"Unregistered global definition");
544 auto [It,
Inserted] = GlobalToGReg.try_emplace(GObj);
547 MCRegister GReg = MAI.getNextIDRegister();
551 MAI.GlobalObjMap[GV] = GReg;
555void SPIRVModuleAnalysisImpl::collectDeclarations(
const Module &M) {
557 std::map<const Value *, unsigned> GlobalToGReg;
563 unsigned PastHeader = 0;
564 for (MachineBasicBlock &
MBB : *MF) {
565 for (MachineInstr &
MI :
MBB) {
566 if (
MI.getNumOperands() == 0)
568 unsigned Opcode =
MI.getOpcode();
569 if (Opcode == SPIRV::OpFunction) {
570 if (PastHeader == 0) {
574 }
else if (Opcode == SPIRV::OpFunctionParameter) {
577 }
else if (PastHeader > 0) {
581 const MachineOperand &DefMO =
MI.getOperand(0);
583 case SPIRV::OpExtension:
584 MAI.Reqs.addExtension(SPIRV::Extension::Extension(DefMO.
getImm()));
585 MAI.setSkipEmission(&
MI);
587 case SPIRV::OpCapability:
588 MAI.Reqs.addCapability(SPIRV::Capability::Capability(DefMO.
getImm()));
589 MAI.setSkipEmission(&
MI);
594 if (DefMO.
isReg() && isDeclSection(
MRI,
MI) &&
595 !MAI.hasRegisterAlias(MF, DefMO.
getReg()))
596 visitDecl(
MRI, SignatureToGReg, GlobalToGReg, MF,
MI);
601 const MachineOperand &InvokeMO =
MI.getOperand(InvokeIdx);
602 if (InvokeMO.
isReg()) {
604 if (!MAI.hasRegisterAlias(MF, InvokeReg)) {
605 if (
const MachineInstr *
DefMI =
609 if (GR->getFunctionDefinitionByUse(FunPtrOp))
610 visitFunPtrUse(InvokeReg, FunPtrOp, SignatureToGReg,
629 if (
MI.getOpcode() == SPIRV::OpDecorate) {
631 auto Dec =
MI.getOperand(1).getImm();
632 if (Dec == SPIRV::Decoration::LinkageAttributes) {
633 auto Lnk =
MI.getOperand(
MI.getNumOperands() - 1).getImm();
634 if (Lnk == SPIRV::LinkageType::Import) {
639 MAI.GlobalObjMap[ImportedFunc] =
640 MAI.getRegisterAlias(
MI.getMF(), Target);
643 }
else if (
MI.getOpcode() == SPIRV::OpFunction) {
646 MCRegister GlobalReg = MAI.getRegisterAlias(
MI.getMF(),
Reg);
648 MAI.GlobalObjMap[
F] = GlobalReg;
660 auto FoundMI = IS.insert(std::move(MISign));
661 if (!FoundMI.second) {
662 if (
MI.getOpcode() == SPIRV::OpDecorate) {
664 "Decoration instructions must have at least 2 operands");
666 "Only OpDecorate instructions can be duplicates");
671 if (
MI.getOperand(1).getImm() != SPIRV::Decoration::FPFastMathMode)
677 assert(OrigMI->getNumOperands() ==
MI.getNumOperands() &&
678 "Original instruction must have the same number of operands");
680 OrigMI->getNumOperands() == 3 &&
681 "FPFastMathMode decoration must have 3 operands for OpDecorate");
682 unsigned OrigFlags = OrigMI->getOperand(2).getImm();
683 unsigned NewFlags =
MI.getOperand(2).getImm();
684 if (OrigFlags == NewFlags)
688 unsigned FinalFlags = OrigFlags | NewFlags;
690 <<
"Warning: Conflicting FPFastMathMode decoration flags "
692 << *OrigMI <<
"Original flags: " << OrigFlags
693 <<
", new flags: " << NewFlags
694 <<
". They will be merged on a best effort basis, but not "
695 "validated. Final flags: "
696 << FinalFlags <<
"\n";
703 assert(
false &&
"No original instruction found for the duplicate "
704 "OpDecorate, but we found one in IS.");
717void SPIRVModuleAnalysisImpl::processOtherInstrs(
const Module &M) {
720 if (
F.isDeclaration())
725 for (MachineBasicBlock &
MBB : *MF)
726 for (MachineInstr &
MI :
MBB) {
727 if (
MI.isDebugValueLike()) {
728 MAI.DebugValueMIs.push_back(&
MI);
731 if (MAI.getSkipEmission(&
MI))
733 const unsigned OpCode =
MI.getOpcode();
734 if (OpCode == SPIRV::OpString) {
736 }
else if (OpCode == SPIRV::OpExtInst &&
MI.getOperand(2).isImm() &&
737 MI.getOperand(2).getImm() ==
738 SPIRV::InstructionSet::
739 NonSemantic_Shader_DebugInfo_100) {
746 MachineOperand Ins =
MI.getOperand(3);
747 namespace NS = SPIRV::NonSemanticExtInst;
748 static constexpr int64_t GlobalNonSemanticDITy[] = {
749 NS::DebugSource, NS::DebugCompilationUnit, NS::DebugInfoNone,
750 NS::DebugTypeBasic, NS::DebugTypePointer};
751 bool IsGlobalDI =
false;
752 for (
unsigned Idx = 0;
Idx < std::size(GlobalNonSemanticDITy); ++
Idx)
753 IsGlobalDI |= Ins.
getImm() == GlobalNonSemanticDITy[
Idx];
756 }
else if (OpCode == SPIRV::OpName || OpCode == SPIRV::OpMemberName) {
758 }
else if (OpCode == SPIRV::OpEntryPoint) {
760 }
else if (TII->isAliasingInstr(
MI)) {
762 }
else if (TII->isDecorationInstr(
MI)) {
763 if (
MI.getOpcode() == SPIRV::OpDecorate &&
764 MI.getOperand(1).getImm() ==
765 static_cast<unsigned>(
766 SPIRV::Decoration::AuxDataInstructionMetadata)) {
767 MAI.setSkipEmission(&
MI);
771 StringSwitch<std::optional<AMDMD>>(Str)
772 .Case(
"amdgpu.no.fine.grained.memory",
773 AMDMD::NoFineGrainedMemory)
774 .Case(
"amdgpu.no.remote.memory", AMDMD::NoRemoteMemory)
775 .Case(
"atomic.ignore.denormal.mode",
776 AMDMD::IgnoreDenormalMode)
777 .Default(std::nullopt);
779 MAI.InstrAuxDataRecords.push_back(
780 {MF,
MI.getOperand(0).getReg(), *MaybeKind});
784 collectFuncNames(
MI, &
F);
785 }
else if (TII->isConstantInstr(
MI)) {
789 }
else if (OpCode == SPIRV::OpFunction) {
790 collectFuncNames(
MI, &
F);
791 }
else if (OpCode == SPIRV::OpTypeForwardPointer) {
799 auto AliasingTier = [](
const MachineInstr *
MI) {
800 switch (
MI->getOpcode()) {
801 case SPIRV::OpAliasDomainDeclINTEL:
803 case SPIRV::OpAliasScopeDeclINTEL:
805 case SPIRV::OpAliasScopeListDeclINTEL:
812 [&](
const MachineInstr *
LHS,
const MachineInstr *
RHS) {
813 return AliasingTier(LHS) < AliasingTier(RHS);
820void SPIRVModuleAnalysisImpl::numberRegistersGlobally(
const Module &M) {
822 if (
F.isDeclaration())
826 for (MachineBasicBlock &
MBB : *MF) {
827 for (MachineInstr &
MI :
MBB) {
828 for (MachineOperand &
Op :
MI.operands()) {
832 if (MAI.hasRegisterAlias(MF,
Reg))
834 MCRegister NewReg = MAI.getNextIDRegister();
835 MAI.setRegisterAlias(MF,
Reg, NewReg);
837 if (
MI.getOpcode() != SPIRV::OpExtInst)
839 auto Set =
MI.getOperand(2).getImm();
840 auto [It,
Inserted] = MAI.ExtInstSetMap.try_emplace(Set);
842 It->second = MAI.getNextIDRegister();
853 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_quad_control))
855 "extension: SPV_KHR_quad_control",
857 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_maximal_reconvergence))
859 "extension: SPV_KHR_maximal_reconvergence",
861 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_quad_control);
862 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_maximal_reconvergence);
867 SPIRV::OperandCategory::OperandCategory Category,
uint32_t i,
869 if (Category == SPIRV::OperandCategory::ExecutionModeOperand &&
870 (i == SPIRV::ExecutionMode::QuadDerivativesKHR ||
871 i == SPIRV::ExecutionMode::RequireFullQuadsKHR))
874 if (Category == SPIRV::OperandCategory::ExecutionModeOperand &&
875 (i == SPIRV::ExecutionMode::DerivativeGroupQuadsKHR ||
876 i == SPIRV::ExecutionMode::DerivativeGroupLinearKHR) &&
877 !ST.canUseExtension(SPIRV::Extension::SPV_KHR_compute_shader_derivatives))
879 " requires the following SPIR-V extension: "
880 "SPV_KHR_compute_shader_derivatives",
885void SPIRV::RequirementHandler::recursiveAddCapabilities(
887 for (
const auto &Cap : ToPrune) {
891 recursiveAddCapabilities(ImplicitDecls);
896 for (
const auto &Cap : ToAdd) {
897 bool IsNewlyInserted = AllCaps.insert(Cap).second;
898 if (!IsNewlyInserted)
902 recursiveAddCapabilities(ImplicitDecls);
903 MinimalCaps.push_back(Cap);
912 if (Req.
Cap.has_value())
918 if (!MaxVersion.empty() && Req.
MinVer > MaxVersion) {
920 <<
" and <= " << MaxVersion <<
"\n");
924 if (MinVersion.empty() || Req.
MinVer > MinVersion)
929 if (!MinVersion.empty() && Req.
MaxVer < MinVersion) {
931 <<
" and >= " << MinVersion <<
"\n");
935 if (MaxVersion.empty() || Req.
MaxVer < MaxVersion)
943 bool IsSatisfiable =
true;
944 auto TargetVer = ST.getSPIRVVersion();
946 if (!MaxVersion.empty() && !TargetVer.empty() && MaxVersion < TargetVer) {
948 dbgs() <<
"Target SPIR-V version too high for required features\n"
949 <<
"Required max version: " << MaxVersion <<
" target version "
950 << TargetVer <<
"\n");
951 IsSatisfiable =
false;
954 if (!MinVersion.empty() && !TargetVer.empty() && MinVersion > TargetVer) {
955 LLVM_DEBUG(
dbgs() <<
"Target SPIR-V version too low for required features\n"
956 <<
"Required min version: " << MinVersion
957 <<
" target version " << TargetVer <<
"\n");
958 IsSatisfiable =
false;
961 if (!MinVersion.empty() && !MaxVersion.empty() && MinVersion > MaxVersion) {
964 <<
"Version is too low for some features and too high for others.\n"
965 <<
"Required SPIR-V min version: " << MinVersion
966 <<
" required SPIR-V max version " << MaxVersion <<
"\n");
967 IsSatisfiable =
false;
970 for (
auto Cap : MinimalCaps) {
975 OperandCategory::CapabilityOperand, Cap)
977 IsSatisfiable =
false;
980 for (
auto Ext : AllExtensions) {
981 if (ST.canUseExtension(Ext))
985 OperandCategory::ExtensionOperand, Ext)
987 IsSatisfiable =
false;
996 for (
const auto Cap : ToAdd)
997 if (AvailableCaps.insert(Cap).second)
999 SPIRV::OperandCategory::CapabilityOperand, Cap));
1003 const Capability::Capability
ToRemove,
1004 const Capability::Capability IfPresent) {
1005 if (AllCaps.contains(IfPresent)) {
1015 addAvailableCaps({Capability::Shader, Capability::Linkage, Capability::Int8,
1016 Capability::Int16});
1020 Capability::GroupNonUniformVote,
1021 Capability::GroupNonUniformArithmetic,
1022 Capability::GroupNonUniformBallot,
1023 Capability::GroupNonUniformClustered,
1024 Capability::GroupNonUniformShuffle,
1025 Capability::GroupNonUniformShuffleRelative,
1026 Capability::GroupNonUniformQuad});
1030 Capability::DotProductInput4x8Bit,
1031 Capability::DotProductInput4x8BitPacked,
1032 Capability::DemoteToHelperInvocation});
1035 for (
auto Extension : ST.getAllAvailableExtensions()) {
1042 if (ST.canUseExtension(Extension::SPV_EXT_shader_subgroup_partitioned))
1045 if (!ST.isShader()) {
1046 initAvailableCapabilitiesForOpenCL(ST);
1050 if (ST.isShader()) {
1051 initAvailableCapabilitiesForVulkan(ST);
1058void RequirementHandler::initAvailableCapabilitiesForOpenCL(
1062 Capability::Kernel, Capability::Vector16,
1063 Capability::Groups, Capability::GenericPointer,
1064 Capability::StorageImageWriteWithoutFormat,
1065 Capability::StorageImageReadWithoutFormat});
1066 if (ST.hasOpenCLFullProfile())
1068 if (ST.hasOpenCLImageSupport()) {
1070 Capability::Image1D, Capability::SampledBuffer,
1071 Capability::ImageBuffer});
1072 if (
ST.isAtLeastOpenCLVer(VersionTuple(2, 0)))
1075 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 1)) &&
1076 ST.isAtLeastOpenCLVer(VersionTuple(2, 2)))
1078 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 4)))
1079 addAvailableCaps({Capability::DenormPreserve, Capability::DenormFlushToZero,
1080 Capability::SignedZeroInfNanPreserve,
1081 Capability::RoundingModeRTE,
1082 Capability::RoundingModeRTZ});
1089void RequirementHandler::initAvailableCapabilitiesForVulkan(
1090 const SPIRVSubtarget &ST) {
1094 Capability::Geometry,
1095 Capability::Float16,
1096 Capability::Float64,
1097 Capability::GroupNonUniform,
1098 Capability::Image1D,
1099 Capability::SampledBuffer,
1100 Capability::ImageBuffer,
1101 Capability::UniformBufferArrayDynamicIndexing,
1102 Capability::SampledImageArrayDynamicIndexing,
1103 Capability::StorageBufferArrayDynamicIndexing,
1104 Capability::StorageImageArrayDynamicIndexing,
1105 Capability::DerivativeControl,
1106 Capability::SampleRateShading,
1108 Capability::ImageQuery,
1109 Capability::ImageGatherExtended,
1110 Capability::Addresses,
1111 Capability::VulkanMemoryModelKHR,
1112 Capability::StorageImageExtendedFormats,
1113 Capability::StorageImageMultisample,
1114 Capability::ImageMSArray});
1116 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 3)) ||
1117 ST.canUseExtension(Extension::SPV_KHR_variable_pointers))
1119 Capability::VariablePointers});
1122 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 3)))
1126 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 5))) {
1128 {Capability::Int64Atomics, Capability::ShaderNonUniformEXT,
1129 Capability::RuntimeDescriptorArrayEXT,
1130 Capability::InputAttachmentArrayDynamicIndexingEXT,
1131 Capability::UniformTexelBufferArrayDynamicIndexingEXT,
1132 Capability::StorageTexelBufferArrayDynamicIndexingEXT,
1133 Capability::UniformBufferArrayNonUniformIndexingEXT,
1134 Capability::SampledImageArrayNonUniformIndexingEXT,
1135 Capability::StorageBufferArrayNonUniformIndexingEXT,
1136 Capability::StorageImageArrayNonUniformIndexingEXT,
1137 Capability::InputAttachmentArrayNonUniformIndexingEXT,
1138 Capability::UniformTexelBufferArrayNonUniformIndexingEXT,
1139 Capability::StorageTexelBufferArrayNonUniformIndexingEXT});
1143 if (
ST.isAtLeastSPIRVVer(VersionTuple(1, 6)))
1145 Capability::StorageImageReadWithoutFormat});
1155 SPIRV::Capability::Capability Cap,
1156 SPIRV::Extension::Extension Ext) {
1160 if (!ST.canUseExtension(Ext))
1162 Twine(
"capability ") +
1164 SPIRV::OperandCategory::CapabilityOperand, Cap) +
1165 " requires SPIR-V 1.3 or the following SPIR-V extension: " +
1177 int64_t DecOp =
MI.getOperand(DecIndex).getImm();
1178 auto Dec =
static_cast<SPIRV::Decoration::Decoration
>(DecOp);
1180 SPIRV::OperandCategory::DecorationOperand, Dec, ST, Reqs));
1182 if (Dec == SPIRV::Decoration::BuiltIn) {
1183 int64_t BuiltInOp =
MI.getOperand(DecIndex + 1).getImm();
1184 auto BuiltIn =
static_cast<SPIRV::BuiltIn::BuiltIn
>(BuiltInOp);
1185 if ((BuiltIn == SPIRV::BuiltIn::BaryCoordKHR ||
1186 BuiltIn == SPIRV::BuiltIn::BaryCoordNoPerspKHR) &&
1187 !ST.canUseExtension(
1188 SPIRV::Extension::SPV_KHR_fragment_shader_barycentric))
1190 "Barycentric built-ins require the following SPIR-V extension: "
1191 "SPV_KHR_fragment_shader_barycentric",
1194 case SPIRV::BuiltIn::BaseVertex:
1195 case SPIRV::BuiltIn::BaseInstance:
1197 Reqs, ST, SPIRV::Capability::DrawParameters,
1198 SPIRV::Extension::SPV_KHR_shader_draw_parameters);
1200 case SPIRV::BuiltIn::ViewIndex:
1202 SPIRV::Extension::SPV_KHR_multiview);
1206 SPIRV::OperandCategory::BuiltInOperand, BuiltIn, ST, Reqs));
1209 }
else if (Dec == SPIRV::Decoration::LinkageAttributes) {
1210 int64_t LinkageOp =
MI.getOperand(
MI.getNumOperands() - 1).getImm();
1211 SPIRV::LinkageType::LinkageType LnkType =
1212 static_cast<SPIRV::LinkageType::LinkageType
>(LinkageOp);
1213 if (LnkType == SPIRV::LinkageType::LinkOnceODR)
1214 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_linkonce_odr);
1215 else if (LnkType == SPIRV::LinkageType::WeakAMD) {
1216 Reqs.
addExtension(SPIRV::Extension::SPV_AMD_weak_linkage);
1219 }
else if (Dec == SPIRV::Decoration::CacheControlLoadINTEL ||
1220 Dec == SPIRV::Decoration::CacheControlStoreINTEL) {
1221 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_cache_controls);
1222 }
else if (Dec == SPIRV::Decoration::HostAccessINTEL) {
1223 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_global_variable_host_access);
1224 }
else if (Dec == SPIRV::Decoration::InitModeINTEL ||
1225 Dec == SPIRV::Decoration::ImplementInRegisterMapINTEL) {
1227 SPIRV::Extension::SPV_INTEL_global_variable_fpga_decorations);
1228 }
else if (Dec == SPIRV::Decoration::NonUniformEXT) {
1230 }
else if (Dec == SPIRV::Decoration::FPMaxErrorDecorationINTEL) {
1232 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_fp_max_error);
1233 }
else if (Dec == SPIRV::Decoration::FPFastMathMode) {
1234 if (ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2)) {
1236 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_float_controls2);
1245 assert(
MI.getNumOperands() >= 8 &&
"Insufficient operands for OpTypeImage");
1248 int64_t ImgFormatOp =
MI.getOperand(7).getImm();
1249 auto ImgFormat =
static_cast<SPIRV::ImageFormat::ImageFormat
>(ImgFormatOp);
1253 bool IsArrayed =
MI.getOperand(4).getImm() == 1;
1254 bool IsMultisampled =
MI.getOperand(5).getImm() == 1;
1255 bool NoSampler =
MI.getOperand(6).getImm() == 2;
1258 switch (
MI.getOperand(2).getImm()) {
1259 case SPIRV::Dim::DIM_1D:
1261 : SPIRV::Capability::Sampled1D);
1263 case SPIRV::Dim::DIM_2D:
1264 if (IsMultisampled && NoSampler)
1266 if (IsMultisampled && IsArrayed)
1269 case SPIRV::Dim::DIM_3D:
1271 case SPIRV::Dim::DIM_Cube:
1275 : SPIRV::Capability::SampledCubeArray);
1277 case SPIRV::Dim::DIM_Rect:
1279 : SPIRV::Capability::SampledRect);
1281 case SPIRV::Dim::DIM_Buffer:
1283 : SPIRV::Capability::SampledBuffer);
1285 case SPIRV::Dim::DIM_SubpassData:
1291 if (!ST.isShader()) {
1292 if (
MI.getNumOperands() > 8 &&
1293 MI.getOperand(8).getImm() == SPIRV::AccessQualifier::ReadWrite)
1302 TypeDef->
getOpcode() == SPIRV::OpTypeFloat &&
1314 return MRI.getVRegDef(
MRI.getVRegDef(
Reg)->getOperand(1).getReg());
1318#define ATOM_FLT_REQ_EXT_MSG(ExtName) \
1319 "The atomic float instruction requires the following SPIR-V " \
1320 "extension: SPV_EXT_shader_atomic_float" ExtName
1325 MI.getMF()->getRegInfo().getVRegDef(
MI.getOperand(1).getReg());
1328 if (Rank != 2 && Rank != 4)
1330 "must be a 2-component or 4 component vector");
1335 if (EltTypeDef->
getOpcode() != SPIRV::OpTypeFloat ||
1338 "The element type for the result type of an atomic vector float "
1339 "instruction must be a 16-bit floating-point scalar");
1346 "The element type for the result type of an atomic vector float "
1347 "instruction cannot be a bfloat16 scalar");
1348 if (!ST.canUseExtension(SPIRV::Extension::SPV_NV_shader_atomic_fp16_vector))
1350 "The atomic float16 vector instruction requires the following SPIR-V "
1351 "extension: SPV_NV_shader_atomic_fp16_vector");
1353 Reqs.
addExtension(SPIRV::Extension::SPV_NV_shader_atomic_fp16_vector);
1354 Reqs.
addCapability(SPIRV::Capability::AtomicFloat16VectorNV);
1361 "Expect register operand in atomic float instruction");
1362 Register TypeReg =
MI.getOperand(1).getReg();
1368 if (TypeDef->
getOpcode() != SPIRV::OpTypeFloat)
1370 "floating-point type scalar");
1373 unsigned Op =
MI.getOpcode();
1374 if (
Op == SPIRV::OpAtomicFAddEXT) {
1375 if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_add))
1377 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_add);
1381 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics))
1383 "The atomic bfloat16 instruction requires the following SPIR-V "
1384 "extension: SPV_INTEL_16bit_atomics",
1386 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics);
1387 Reqs.
addCapability(SPIRV::Capability::AtomicBFloat16AddINTEL);
1389 if (!ST.canUseExtension(
1390 SPIRV::Extension::SPV_EXT_shader_atomic_float16_add))
1392 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float16_add);
1404 "Unexpected floating-point type width in atomic float instruction");
1407 if (!ST.canUseExtension(
1408 SPIRV::Extension::SPV_EXT_shader_atomic_float_min_max))
1410 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_min_max);
1414 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics))
1416 "The atomic bfloat16 instruction requires the following SPIR-V "
1417 "extension: SPV_INTEL_16bit_atomics",
1419 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics);
1420 Reqs.
addCapability(SPIRV::Capability::AtomicBFloat16MinMaxINTEL);
1422 Reqs.
addCapability(SPIRV::Capability::AtomicFloat16MinMaxEXT);
1426 Reqs.
addCapability(SPIRV::Capability::AtomicFloat32MinMaxEXT);
1429 Reqs.
addCapability(SPIRV::Capability::AtomicFloat64MinMaxEXT);
1433 "Unexpected floating-point type width in atomic float instruction");
1439 if (ImageInst->
getOpcode() != SPIRV::OpTypeImage)
1443 return Dim == SPIRV::Dim::DIM_Buffer && Sampled == 1;
1447 if (ImageInst->
getOpcode() != SPIRV::OpTypeImage)
1451 return Dim == SPIRV::Dim::DIM_Buffer && Sampled == 2;
1455 if (ImageInst->
getOpcode() != SPIRV::OpTypeImage)
1459 return Dim != SPIRV::Dim::DIM_Buffer && Sampled == 1;
1463 if (ImageInst->
getOpcode() != SPIRV::OpTypeImage)
1467 return Dim == SPIRV::Dim::DIM_SubpassData && Sampled == 2;
1471 if (ImageInst->
getOpcode() != SPIRV::OpTypeImage)
1475 return Dim != SPIRV::Dim::DIM_Buffer && Sampled == 2;
1479 if (SampledImageInst->
getOpcode() != SPIRV::OpTypeSampledImage)
1484 auto *ImageInst =
MRI.getUniqueVRegDef(ImageReg);
1489 for (
const auto &
MI :
MRI.reg_instructions(
Reg)) {
1490 if (
MI.getOpcode() != SPIRV::OpDecorate)
1494 if (Dec == SPIRV::Decoration::NonUniformEXT)
1507 Register ResTypeReg = Instr.getOperand(1).getReg();
1512 if (
StorageClass != SPIRV::StorageClass::StorageClass::UniformConstant &&
1513 StorageClass != SPIRV::StorageClass::StorageClass::Uniform &&
1514 StorageClass != SPIRV::StorageClass::StorageClass::StorageBuffer) {
1521 auto FirstIndexReg = Instr.getOperand(3).getReg();
1522 bool FirstIndexIsConstant =
1523 Subtarget.getInstrInfo()->isConstantInstr(*
MRI.getVRegDef(FirstIndexReg));
1525 if (
StorageClass == SPIRV::StorageClass::StorageClass::StorageBuffer) {
1528 SPIRV::Capability::StorageBufferArrayNonUniformIndexingEXT);
1529 else if (!FirstIndexIsConstant)
1531 SPIRV::Capability::StorageBufferArrayDynamicIndexing);
1537 if (PointeeType->
getOpcode() != SPIRV::OpTypeImage &&
1538 PointeeType->
getOpcode() != SPIRV::OpTypeSampledImage &&
1539 PointeeType->
getOpcode() != SPIRV::OpTypeSampler) {
1546 SPIRV::Capability::UniformTexelBufferArrayNonUniformIndexingEXT);
1547 else if (!FirstIndexIsConstant)
1549 SPIRV::Capability::UniformTexelBufferArrayDynamicIndexingEXT);
1553 SPIRV::Capability::InputAttachmentArrayNonUniformIndexingEXT);
1554 else if (!FirstIndexIsConstant)
1556 SPIRV::Capability::InputAttachmentArrayDynamicIndexingEXT);
1560 SPIRV::Capability::StorageTexelBufferArrayNonUniformIndexingEXT);
1561 else if (!FirstIndexIsConstant)
1563 SPIRV::Capability::StorageTexelBufferArrayDynamicIndexingEXT);
1566 PointeeType->
getOpcode() == SPIRV::OpTypeSampler) {
1569 SPIRV::Capability::SampledImageArrayNonUniformIndexingEXT);
1570 else if (!FirstIndexIsConstant)
1572 SPIRV::Capability::SampledImageArrayDynamicIndexing);
1576 SPIRV::Capability::StorageImageArrayNonUniformIndexingEXT);
1577 else if (!FirstIndexIsConstant)
1579 SPIRV::Capability::StorageImageArrayDynamicIndexing);
1584 if (TypeInst->
getOpcode() != SPIRV::OpTypeImage)
1593 if (ST.canUseExtension(SPIRV::Extension::SPV_KHR_integer_dot_product))
1594 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_integer_dot_product);
1598 assert(
MI.getOperand(2).isReg() &&
"Unexpected operand in dot");
1600 ST.getSPIRVGlobalRegistry());
1601 assert(TypeDef &&
"Unexpected type instruction for dot input");
1602 if (TypeDef->
getOpcode() == SPIRV::OpTypeInt) {
1604 Reqs.
addCapability(SPIRV::Capability::DotProductInput4x8BitPacked);
1611 "Dot operand of 8-bit integer type requires 4 components");
1612 Reqs.
addCapability(SPIRV::Capability::DotProductInput4x8Bit);
1628 unsigned AddrSpace = ASOp.
getImm();
1629 if (AddrSpace != SPIRV::StorageClass::UniformConstant) {
1630 if (!ST.canUseExtension(
1632 SPV_EXT_relaxed_printf_string_address_space)) {
1634 "required because printf uses a format string not "
1635 "in constant address space.",
1639 SPIRV::Extension::SPV_EXT_relaxed_printf_string_address_space);
1648 if (
MI.getNumOperands() <= OpIdx)
1650 uint32_t Mask =
MI.getOperand(OpIdx).getImm();
1652 if (Mask & (1U <<
I))
1663 if (ElemTypeDef->
getOpcode() == SPIRV::OpTypePointer &&
1664 ST.canUseExtension(SPIRV::Extension::SPV_INTEL_masked_gather_scatter)) {
1665 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_masked_gather_scatter);
1666 Reqs.
addCapability(SPIRV::Capability::MaskedGatherScatterINTEL);
1674 unsigned Op =
MI.getOpcode();
1676 case SPIRV::OpMemoryModel: {
1677 int64_t Addr =
MI.getOperand(0).getImm();
1680 int64_t Mem =
MI.getOperand(1).getImm();
1685 case SPIRV::OpEntryPoint: {
1686 int64_t Exe =
MI.getOperand(0).getImm();
1691 case SPIRV::OpExecutionMode:
1692 case SPIRV::OpExecutionModeId: {
1693 int64_t Exe =
MI.getOperand(1).getImm();
1698 case SPIRV::OpTypeMatrix:
1701 case SPIRV::OpTypeInt: {
1702 unsigned BitWidth =
MI.getOperand(1).getImm();
1710 ST.canUseExtension(SPIRV::Extension::SPV_INTEL_int4)) {
1714 if (!ST.canUseExtension(
1715 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_integers))
1717 "OpTypeInt type with a width other than 8, 16, 32 or 64 bits "
1718 "requires the following SPIR-V extension: "
1719 "SPV_ALTERA_arbitrary_precision_integers");
1721 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_integers);
1722 Reqs.
addCapability(SPIRV::Capability::ArbitraryPrecisionIntegersALTERA);
1726 case SPIRV::OpDot: {
1730 Reqs.
addCapability(SPIRV::Capability::BFloat16DotProductKHR);
1733 case SPIRV::OpTypeFloat: {
1734 unsigned BitWidth =
MI.getOperand(1).getImm();
1739 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_bfloat16))
1741 "following SPIR-V extension: SPV_KHR_bfloat16",
1751 case SPIRV::OpTypeVector: {
1752 unsigned NumComponents =
MI.getOperand(2).getImm();
1753 if (NumComponents == 8 || NumComponents == 16)
1758 "OpTypeVector with " +
Twine(NumComponents) +
1759 " components requires the following SPIR-V extension: "
1760 "SPV_EXT_long_vector");
1765 case SPIRV::OpTypeVectorIdEXT: {
1766 if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_long_vector))
1768 "extension: SPV_EXT_long_vector extension");
1769 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_long_vector);
1774 case SPIRV::OpTypePointer: {
1775 auto SC =
MI.getOperand(1).getImm();
1786 (TypeDef->
getOpcode() == SPIRV::OpTypeFloat) &&
1791 case SPIRV::OpExtInst: {
1792 if (
MI.getOperand(2).getImm() ==
1793 static_cast<int64_t
>(
1794 SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100)) {
1795 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_non_semantic_info);
1798 if (
MI.getOperand(2).getImm() ==
1799 static_cast<int64_t
>(SPIRV::InstructionSet::NonSemantic_DebugBreak)) {
1803 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_non_semantic_info);
1806 if (
MI.getOperand(3).getImm() ==
1807 static_cast<int64_t
>(SPIRV::OpenCLExtInst::printf)) {
1811 if (
MI.getOperand(2).getImm() ==
1812 static_cast<int64_t
>(SPIRV::InstructionSet::OpenCL_std)) {
1818 if (TypeDef && TypeDef->getOpcode() == SPIRV::OpTypeVector)
1819 TypeDef =
MRI.getVRegDef(TypeDef->getOperand(1).getReg());
1824 bool UsesBFloat16 = IsBFloat16(
MRI.getVRegDef(
MI.getOperand(1).getReg()));
1825 for (
unsigned I = 4,
E =
MI.getNumOperands();
I <
E && !UsesBFloat16;
1834 if (!ST.canUseExtension(
1835 SPIRV::Extension::SPV_EXT_bfloat16_arithmetic)) {
1837 MI,
"OpenCL Extended instructions with bfloat16 require the "
1838 "following SPIR-V extension: SPV_EXT_bfloat16_arithmetic");
1841 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_bfloat16_arithmetic);
1842 Reqs.
addCapability(SPIRV::Capability::BFloat16ArithmeticEXT);
1847 case SPIRV::OpAliasDomainDeclINTEL:
1848 case SPIRV::OpAliasScopeDeclINTEL:
1849 case SPIRV::OpAliasScopeListDeclINTEL: {
1850 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_memory_access_aliasing);
1851 Reqs.
addCapability(SPIRV::Capability::MemoryAccessAliasingINTEL);
1854 case SPIRV::OpBitReverse:
1855 case SPIRV::OpBitFieldInsert:
1856 case SPIRV::OpBitFieldSExtract:
1857 case SPIRV::OpBitFieldUExtract:
1858 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_bit_instructions)) {
1862 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_bit_instructions);
1865 case SPIRV::OpTypeRuntimeArray:
1868 case SPIRV::OpTypeOpaque:
1869 case SPIRV::OpTypeEvent:
1872 case SPIRV::OpTypePipe:
1873 case SPIRV::OpTypeReserveId:
1876 case SPIRV::OpTypePipeStorage:
1879 case SPIRV::OpTypeDeviceEvent:
1880 case SPIRV::OpTypeQueue:
1881 case SPIRV::OpBuildNDRange:
1882 case SPIRV::OpEnqueueKernel:
1883 case SPIRV::OpGetKernelNDrangeSubGroupCount:
1884 case SPIRV::OpGetKernelNDrangeMaxSubGroupSize:
1885 case SPIRV::OpGetKernelWorkGroupSize:
1886 case SPIRV::OpGetKernelPreferredWorkGroupSizeMultiple:
1889 case SPIRV::OpDecorate:
1890 case SPIRV::OpDecorateId:
1891 case SPIRV::OpDecorateString:
1894 case SPIRV::OpMemberDecorate:
1895 case SPIRV::OpMemberDecorateString:
1898 case SPIRV::OpInBoundsPtrAccessChain:
1901 case SPIRV::OpConstantSampler:
1904 case SPIRV::OpInBoundsAccessChain:
1905 case SPIRV::OpAccessChain:
1908 case SPIRV::OpTypeImage:
1911 case SPIRV::OpTypeSampler:
1912 if (!ST.isShader()) {
1916 case SPIRV::OpTypeForwardPointer:
1920 case SPIRV::OpAtomicFlagTestAndSet:
1921 case SPIRV::OpAtomicLoad:
1922 case SPIRV::OpAtomicStore:
1923 case SPIRV::OpAtomicExchange:
1924 case SPIRV::OpAtomicCompareExchange:
1925 case SPIRV::OpAtomicCompareExchangeWeak:
1926 case SPIRV::OpAtomicIIncrement:
1927 case SPIRV::OpAtomicIDecrement:
1928 case SPIRV::OpAtomicIAdd:
1929 case SPIRV::OpAtomicISub:
1930 case SPIRV::OpAtomicUMin:
1931 case SPIRV::OpAtomicUMax:
1932 case SPIRV::OpAtomicSMin:
1933 case SPIRV::OpAtomicSMax:
1934 case SPIRV::OpAtomicAnd:
1935 case SPIRV::OpAtomicOr:
1936 case SPIRV::OpAtomicXor: {
1939 if (
Op == SPIRV::OpAtomicStore) {
1942 ST.getSPIRVGlobalRegistry());
1943 assert(TypeDef &&
"Unexpected type instruction for OpAtomicStore");
1945 assert(
MI.getOperand(1).isReg() &&
"Unexpected operand in atomic");
1946 TypeDef =
MRI.getVRegDef(
MI.getOperand(1).getReg());
1949 if (TypeDef->
getOpcode() == SPIRV::OpTypeInt) {
1954 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics))
1956 "16-bit integer atomic operations require the following SPIR-V "
1957 "extension: SPV_INTEL_16bit_atomics",
1959 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics);
1961 case SPIRV::OpAtomicLoad:
1962 case SPIRV::OpAtomicStore:
1963 case SPIRV::OpAtomicExchange:
1964 case SPIRV::OpAtomicCompareExchange:
1965 case SPIRV::OpAtomicCompareExchangeWeak:
1967 SPIRV::Capability::AtomicInt16CompareExchangeINTEL);
1975 if (
is_contained({SPIRV::OpAtomicLoad, SPIRV::OpAtomicStore,
1976 SPIRV::OpAtomicExchange},
1978 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics))
1980 "The atomic bfloat16 instruction requires the following SPIR-V "
1981 "extension: SPV_INTEL_16bit_atomics",
1983 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_16bit_atomics);
1984 Reqs.
addCapability(SPIRV::Capability::AtomicBFloat16LoadStoreINTEL);
1989 case SPIRV::OpGroupNonUniformIAdd:
1990 case SPIRV::OpGroupNonUniformFAdd:
1991 case SPIRV::OpGroupNonUniformIMul:
1992 case SPIRV::OpGroupNonUniformFMul:
1993 case SPIRV::OpGroupNonUniformSMin:
1994 case SPIRV::OpGroupNonUniformUMin:
1995 case SPIRV::OpGroupNonUniformFMin:
1996 case SPIRV::OpGroupNonUniformSMax:
1997 case SPIRV::OpGroupNonUniformUMax:
1998 case SPIRV::OpGroupNonUniformFMax:
1999 case SPIRV::OpGroupNonUniformBitwiseAnd:
2000 case SPIRV::OpGroupNonUniformBitwiseOr:
2001 case SPIRV::OpGroupNonUniformBitwiseXor:
2002 case SPIRV::OpGroupNonUniformLogicalAnd:
2003 case SPIRV::OpGroupNonUniformLogicalOr:
2004 case SPIRV::OpGroupNonUniformLogicalXor: {
2006 int64_t GroupOp =
MI.getOperand(3).getImm();
2008 case SPIRV::GroupOperation::Reduce:
2009 case SPIRV::GroupOperation::InclusiveScan:
2010 case SPIRV::GroupOperation::ExclusiveScan:
2011 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformArithmetic);
2013 case SPIRV::GroupOperation::ClusteredReduce:
2014 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformClustered);
2016 case SPIRV::GroupOperation::PartitionedReduceNV:
2017 case SPIRV::GroupOperation::PartitionedInclusiveScanNV:
2018 case SPIRV::GroupOperation::PartitionedExclusiveScanNV:
2019 if (ST.canUseExtension(
2020 SPIRV::Extension::SPV_EXT_shader_subgroup_partitioned))
2022 SPIRV::Extension::SPV_EXT_shader_subgroup_partitioned);
2024 Reqs.
addExtension(SPIRV::Extension::SPV_NV_shader_subgroup_partitioned);
2025 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformPartitionedNV);
2030 case SPIRV::OpGroupNonUniformQuadSwap:
2033 case SPIRV::OpImageQueryLod:
2036 case SPIRV::OpImageQuerySize:
2037 case SPIRV::OpImageQuerySizeLod:
2038 case SPIRV::OpImageQueryLevels:
2039 case SPIRV::OpImageQuerySamples:
2043 case SPIRV::OpImageQueryFormat: {
2044 Register ResultReg =
MI.getOperand(0).getReg();
2046 static const unsigned CompareOps[] = {
2047 SPIRV::OpIEqual, SPIRV::OpINotEqual,
2048 SPIRV::OpUGreaterThan, SPIRV::OpUGreaterThanEqual,
2049 SPIRV::OpULessThan, SPIRV::OpULessThanEqual,
2050 SPIRV::OpSGreaterThan, SPIRV::OpSGreaterThanEqual,
2051 SPIRV::OpSLessThan, SPIRV::OpSLessThanEqual};
2053 auto CheckAndAddExtension = [&](int64_t ImmVal) {
2054 if (ImmVal == 4323 || ImmVal == 4324) {
2055 if (ST.canUseExtension(SPIRV::Extension::SPV_EXT_image_raw10_raw12))
2056 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_image_raw10_raw12);
2059 "SPV_EXT_image_raw10_raw12 extension");
2064 unsigned Opc = UseInst.getOpcode();
2066 if (
Opc == SPIRV::OpSwitch) {
2069 CheckAndAddExtension(
Op.getImm());
2071 for (
unsigned i = 1; i < UseInst.getNumOperands(); ++i) {
2074 if (ConstInst && ConstInst->
getOpcode() == SPIRV::OpConstantI) {
2077 CheckAndAddExtension(ImmVal);
2085 case SPIRV::OpGroupNonUniformShuffle:
2086 case SPIRV::OpGroupNonUniformShuffleXor:
2087 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformShuffle);
2089 case SPIRV::OpGroupNonUniformShuffleUp:
2090 case SPIRV::OpGroupNonUniformShuffleDown:
2091 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformShuffleRelative);
2093 case SPIRV::OpGroupAll:
2094 case SPIRV::OpGroupAny:
2095 case SPIRV::OpGroupBroadcast:
2096 case SPIRV::OpGroupIAdd:
2097 case SPIRV::OpGroupFAdd:
2098 case SPIRV::OpGroupFMin:
2099 case SPIRV::OpGroupUMin:
2100 case SPIRV::OpGroupSMin:
2101 case SPIRV::OpGroupFMax:
2102 case SPIRV::OpGroupUMax:
2103 case SPIRV::OpGroupSMax:
2106 case SPIRV::OpGroupNonUniformElect:
2109 case SPIRV::OpGroupNonUniformAll:
2110 case SPIRV::OpGroupNonUniformAny:
2111 case SPIRV::OpGroupNonUniformAllEqual:
2114 case SPIRV::OpGroupNonUniformBroadcast:
2115 case SPIRV::OpGroupNonUniformBroadcastFirst:
2116 case SPIRV::OpGroupNonUniformBallot:
2117 case SPIRV::OpGroupNonUniformInverseBallot:
2118 case SPIRV::OpGroupNonUniformBallotBitExtract:
2119 case SPIRV::OpGroupNonUniformBallotBitCount:
2120 case SPIRV::OpGroupNonUniformBallotFindLSB:
2121 case SPIRV::OpGroupNonUniformBallotFindMSB:
2122 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformBallot);
2124 case SPIRV::OpSubgroupShuffleINTEL:
2125 case SPIRV::OpSubgroupShuffleDownINTEL:
2126 case SPIRV::OpSubgroupShuffleUpINTEL:
2127 case SPIRV::OpSubgroupShuffleXorINTEL:
2128 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
2129 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
2130 Reqs.
addCapability(SPIRV::Capability::SubgroupShuffleINTEL);
2133 case SPIRV::OpSubgroupBlockReadINTEL:
2134 case SPIRV::OpSubgroupBlockWriteINTEL:
2135 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
2136 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
2137 Reqs.
addCapability(SPIRV::Capability::SubgroupBufferBlockIOINTEL);
2140 case SPIRV::OpSubgroupImageBlockReadINTEL:
2141 case SPIRV::OpSubgroupImageBlockWriteINTEL:
2142 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
2143 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
2144 Reqs.
addCapability(SPIRV::Capability::SubgroupImageBlockIOINTEL);
2147 case SPIRV::OpSubgroupImageMediaBlockReadINTEL:
2148 case SPIRV::OpSubgroupImageMediaBlockWriteINTEL:
2149 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_media_block_io)) {
2150 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_media_block_io);
2151 Reqs.
addCapability(SPIRV::Capability::SubgroupImageMediaBlockIOINTEL);
2154 case SPIRV::OpAssumeTrueKHR:
2155 case SPIRV::OpExpectKHR:
2156 if (ST.canUseExtension(SPIRV::Extension::SPV_KHR_expect_assume)) {
2157 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_expect_assume);
2161 case SPIRV::OpFmaKHR:
2162 if (ST.canUseExtension(SPIRV::Extension::SPV_KHR_fma)) {
2167 case SPIRV::OpPtrCastToCrossWorkgroupINTEL:
2168 case SPIRV::OpCrossWorkgroupCastToPtrINTEL:
2169 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_usm_storage_classes)) {
2170 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_usm_storage_classes);
2171 Reqs.
addCapability(SPIRV::Capability::USMStorageClassesINTEL);
2174 case SPIRV::OpConstantFunctionPointerINTEL:
2175 case SPIRV::OpFunctionPointerCallINTEL:
2176 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_function_pointers)) {
2177 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_function_pointers);
2178 Reqs.
addCapability(SPIRV::Capability::FunctionPointersINTEL);
2181 case SPIRV::OpGroupNonUniformQuadAllKHR:
2185 case SPIRV::OpGroupNonUniformRotateKHR:
2186 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_subgroup_rotate))
2188 "following SPIR-V extension: SPV_KHR_subgroup_rotate",
2190 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_subgroup_rotate);
2191 Reqs.
addCapability(SPIRV::Capability::GroupNonUniformRotateKHR);
2194 case SPIRV::OpFixedCosALTERA:
2195 case SPIRV::OpFixedSinALTERA:
2196 case SPIRV::OpFixedCosPiALTERA:
2197 case SPIRV::OpFixedSinPiALTERA:
2198 case SPIRV::OpFixedExpALTERA:
2199 case SPIRV::OpFixedLogALTERA:
2200 case SPIRV::OpFixedRecipALTERA:
2201 case SPIRV::OpFixedSqrtALTERA:
2202 case SPIRV::OpFixedSinCosALTERA:
2203 case SPIRV::OpFixedSinCosPiALTERA:
2204 case SPIRV::OpFixedRsqrtALTERA:
2205 if (!ST.canUseExtension(
2206 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_fixed_point))
2208 "following SPIR-V extension: "
2209 "SPV_ALTERA_arbitrary_precision_fixed_point",
2212 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_fixed_point);
2213 Reqs.
addCapability(SPIRV::Capability::ArbitraryPrecisionFixedPointALTERA);
2215 case SPIRV::OpGroupIMulKHR:
2216 case SPIRV::OpGroupFMulKHR:
2217 case SPIRV::OpGroupBitwiseAndKHR:
2218 case SPIRV::OpGroupBitwiseOrKHR:
2219 case SPIRV::OpGroupBitwiseXorKHR:
2220 case SPIRV::OpGroupLogicalAndKHR:
2221 case SPIRV::OpGroupLogicalOrKHR:
2222 case SPIRV::OpGroupLogicalXorKHR:
2223 if (ST.canUseExtension(
2224 SPIRV::Extension::SPV_KHR_uniform_group_instructions)) {
2225 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_uniform_group_instructions);
2226 Reqs.
addCapability(SPIRV::Capability::GroupUniformArithmeticKHR);
2229 case SPIRV::OpReadClockKHR:
2230 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_shader_clock))
2232 "following SPIR-V extension: SPV_KHR_shader_clock",
2234 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_shader_clock);
2237 case SPIRV::OpAbortKHR:
2238 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_abort))
2240 "following SPIR-V extension: SPV_KHR_abort",
2245 case SPIRV::OpPoisonKHR:
2246 case SPIRV::OpFreezeKHR:
2247 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_poison_freeze))
2249 "following SPIR-V extension: SPV_KHR_poison_freeze",
2251 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_poison_freeze);
2254 case SPIRV::OpAtomicFAddEXT:
2255 case SPIRV::OpAtomicFMinEXT:
2256 case SPIRV::OpAtomicFMaxEXT:
2259 case SPIRV::OpConvertBF16ToFINTEL:
2260 case SPIRV::OpConvertFToBF16INTEL:
2261 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_bfloat16_conversion)) {
2262 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_bfloat16_conversion);
2263 Reqs.
addCapability(SPIRV::Capability::BFloat16ConversionINTEL);
2266 case SPIRV::OpRoundFToTF32INTEL:
2267 if (ST.canUseExtension(
2268 SPIRV::Extension::SPV_INTEL_tensor_float32_conversion)) {
2269 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_tensor_float32_conversion);
2270 Reqs.
addCapability(SPIRV::Capability::TensorFloat32RoundingINTEL);
2273 case SPIRV::OpVariableLengthArrayINTEL:
2274 case SPIRV::OpSaveMemoryINTEL:
2275 case SPIRV::OpRestoreMemoryINTEL:
2276 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_variable_length_array)) {
2277 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_variable_length_array);
2278 Reqs.
addCapability(SPIRV::Capability::VariableLengthArrayINTEL);
2281 case SPIRV::OpUntypedVariableLengthArrayINTEL:
2282 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_variable_length_array)) {
2283 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_variable_length_array);
2284 Reqs.
addCapability(SPIRV::Capability::UntypedVariableLengthArrayINTEL);
2287 case SPIRV::OpAsmTargetINTEL:
2288 case SPIRV::OpAsmINTEL:
2289 case SPIRV::OpAsmCallINTEL:
2290 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_inline_assembly)) {
2291 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_inline_assembly);
2295 case SPIRV::OpTypeCooperativeMatrixKHR: {
2296 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix))
2298 "OpTypeCooperativeMatrixKHR type requires the "
2299 "following SPIR-V extension: SPV_KHR_cooperative_matrix",
2301 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix);
2302 Reqs.
addCapability(SPIRV::Capability::CooperativeMatrixKHR);
2306 Reqs.
addCapability(SPIRV::Capability::BFloat16CooperativeMatrixKHR);
2309 case SPIRV::OpArithmeticFenceEXT:
2310 if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_arithmetic_fence))
2312 "following SPIR-V extension: SPV_EXT_arithmetic_fence",
2314 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_arithmetic_fence);
2317 case SPIRV::OpControlBarrierArriveINTEL:
2318 case SPIRV::OpControlBarrierWaitINTEL:
2319 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_split_barrier)) {
2320 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_split_barrier);
2324 case SPIRV::OpCooperativeMatrixMulAddKHR: {
2325 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix))
2327 "following SPIR-V extension: "
2328 "SPV_KHR_cooperative_matrix",
2330 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix);
2331 Reqs.
addCapability(SPIRV::Capability::CooperativeMatrixKHR);
2332 constexpr unsigned MulAddMaxSize = 6;
2333 if (
MI.getNumOperands() != MulAddMaxSize)
2335 const int64_t CoopOperands =
MI.getOperand(MulAddMaxSize - 1).getImm();
2337 SPIRV::CooperativeMatrixOperands::MatrixAAndBTF32ComponentsINTEL) {
2338 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix))
2340 "require the following SPIR-V extension: "
2341 "SPV_INTEL_joint_matrix",
2343 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2345 SPIRV::Capability::CooperativeMatrixTF32ComponentTypeINTEL);
2348 MatrixAAndBBFloat16ComponentsINTEL ||
2350 SPIRV::CooperativeMatrixOperands::MatrixCBFloat16ComponentsINTEL ||
2352 MatrixResultBFloat16ComponentsINTEL) {
2353 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix))
2355 "require the following SPIR-V extension: "
2356 "SPV_INTEL_joint_matrix",
2358 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2360 SPIRV::Capability::CooperativeMatrixBFloat16ComponentTypeINTEL);
2364 case SPIRV::OpCooperativeMatrixLoadKHR:
2365 case SPIRV::OpCooperativeMatrixStoreKHR:
2366 case SPIRV::OpCooperativeMatrixLoadCheckedINTEL:
2367 case SPIRV::OpCooperativeMatrixStoreCheckedINTEL:
2368 case SPIRV::OpCooperativeMatrixPrefetchINTEL: {
2369 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix))
2371 "following SPIR-V extension: "
2372 "SPV_KHR_cooperative_matrix",
2374 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix);
2375 Reqs.
addCapability(SPIRV::Capability::CooperativeMatrixKHR);
2381 case SPIRV::OpCooperativeMatrixLoadKHR:
2384 case SPIRV::OpCooperativeMatrixStoreKHR:
2387 case SPIRV::OpCooperativeMatrixLoadCheckedINTEL:
2390 case SPIRV::OpCooperativeMatrixStoreCheckedINTEL:
2391 case SPIRV::OpCooperativeMatrixPrefetchINTEL:
2397 Register RegLayout =
MI.getOperand(LayoutNum).getReg();
2400 if (MILayout->
getOpcode() == SPIRV::OpConstantI) {
2403 static_cast<unsigned>(SPIRV::CooperativeMatrixLayout::PackedINTEL)) {
2404 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix))
2406 "extension: SPV_INTEL_joint_matrix",
2408 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2409 Reqs.
addCapability(SPIRV::Capability::PackedCooperativeMatrixINTEL);
2414 if (
Op == SPIRV::OpCooperativeMatrixLoadKHR ||
2415 Op == SPIRV::OpCooperativeMatrixStoreKHR)
2418 std::string InstName;
2420 case SPIRV::OpCooperativeMatrixPrefetchINTEL:
2421 InstName =
"OpCooperativeMatrixPrefetchINTEL";
2423 case SPIRV::OpCooperativeMatrixLoadCheckedINTEL:
2424 InstName =
"OpCooperativeMatrixLoadCheckedINTEL";
2426 case SPIRV::OpCooperativeMatrixStoreCheckedINTEL:
2427 InstName =
"OpCooperativeMatrixStoreCheckedINTEL";
2431 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix)) {
2432 const std::string ErrorMsg =
2433 InstName +
" instruction requires the "
2434 "following SPIR-V extension: SPV_INTEL_joint_matrix";
2437 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2438 if (
Op == SPIRV::OpCooperativeMatrixPrefetchINTEL) {
2439 Reqs.
addCapability(SPIRV::Capability::CooperativeMatrixPrefetchINTEL);
2443 SPIRV::Capability::CooperativeMatrixCheckedInstructionsINTEL);
2446 case SPIRV::OpCooperativeMatrixConstructCheckedINTEL:
2447 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix))
2449 "instructions require the following SPIR-V extension: "
2450 "SPV_INTEL_joint_matrix",
2452 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2454 SPIRV::Capability::CooperativeMatrixCheckedInstructionsINTEL);
2456 case SPIRV::OpReadPipeBlockingALTERA:
2457 case SPIRV::OpWritePipeBlockingALTERA:
2458 if (ST.canUseExtension(SPIRV::Extension::SPV_ALTERA_blocking_pipes)) {
2459 Reqs.
addExtension(SPIRV::Extension::SPV_ALTERA_blocking_pipes);
2463 case SPIRV::OpCooperativeMatrixGetElementCoordINTEL:
2464 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_joint_matrix))
2466 "following SPIR-V extension: SPV_INTEL_joint_matrix",
2468 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_joint_matrix);
2470 SPIRV::Capability::CooperativeMatrixInvocationInstructionsINTEL);
2472 case SPIRV::OpConvertHandleToImageINTEL:
2473 case SPIRV::OpConvertHandleToSamplerINTEL:
2474 case SPIRV::OpConvertHandleToSampledImageINTEL: {
2475 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_bindless_images))
2477 "instructions require the following SPIR-V extension: "
2478 "SPV_INTEL_bindless_images",
2481 SPIRV::AddressingModel::AddressingModel AddrModel = MAI.
Addr;
2483 if (
Op == SPIRV::OpConvertHandleToImageINTEL &&
2484 TyDef->
getOpcode() != SPIRV::OpTypeImage) {
2486 "OpConvertHandleToImageINTEL",
2488 }
else if (
Op == SPIRV::OpConvertHandleToSamplerINTEL &&
2489 TyDef->
getOpcode() != SPIRV::OpTypeSampler) {
2491 "OpConvertHandleToSamplerINTEL",
2493 }
else if (
Op == SPIRV::OpConvertHandleToSampledImageINTEL &&
2494 TyDef->
getOpcode() != SPIRV::OpTypeSampledImage) {
2496 "OpConvertHandleToSampledImageINTEL",
2502 if (!(Bitwidth == 32 && AddrModel == SPIRV::AddressingModel::Physical32) &&
2503 !(Bitwidth == 64 && AddrModel == SPIRV::AddressingModel::Physical64)) {
2505 "Parameter value must be a 32-bit scalar in case of "
2506 "Physical32 addressing model or a 64-bit scalar in case of "
2507 "Physical64 addressing model",
2510 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_bindless_images);
2514 case SPIRV::OpSubgroup2DBlockLoadINTEL:
2515 case SPIRV::OpSubgroup2DBlockLoadTransposeINTEL:
2516 case SPIRV::OpSubgroup2DBlockLoadTransformINTEL:
2517 case SPIRV::OpSubgroup2DBlockPrefetchINTEL:
2518 case SPIRV::OpSubgroup2DBlockStoreINTEL: {
2519 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_2d_block_io))
2521 "Prefetch/Store]INTEL instructions require the "
2522 "following SPIR-V extension: SPV_INTEL_2d_block_io",
2524 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_2d_block_io);
2525 Reqs.
addCapability(SPIRV::Capability::Subgroup2DBlockIOINTEL);
2527 if (
Op == SPIRV::OpSubgroup2DBlockLoadTransposeINTEL) {
2528 Reqs.
addCapability(SPIRV::Capability::Subgroup2DBlockTransposeINTEL);
2531 if (
Op == SPIRV::OpSubgroup2DBlockLoadTransformINTEL) {
2532 Reqs.
addCapability(SPIRV::Capability::Subgroup2DBlockTransformINTEL);
2537 case SPIRV::OpKill: {
2540 case SPIRV::OpDemoteToHelperInvocation:
2541 Reqs.
addCapability(SPIRV::Capability::DemoteToHelperInvocation);
2543 if (ST.canUseExtension(
2544 SPIRV::Extension::SPV_EXT_demote_to_helper_invocation)) {
2547 SPIRV::Extension::SPV_EXT_demote_to_helper_invocation);
2552 case SPIRV::OpSUDot:
2553 case SPIRV::OpSDotAccSat:
2554 case SPIRV::OpUDotAccSat:
2555 case SPIRV::OpSUDotAccSat:
2558 case SPIRV::OpImageSampleImplicitLod:
2559 case SPIRV::OpImageFetch:
2563 case SPIRV::OpImageSampleExplicitLod:
2566 case SPIRV::OpImageSampleDrefImplicitLod:
2567 case SPIRV::OpImageSampleDrefExplicitLod:
2568 case SPIRV::OpImageDrefGather:
2569 case SPIRV::OpImageGather:
2573 case SPIRV::OpImageRead: {
2574 Register ImageReg =
MI.getOperand(2).getReg();
2575 SPIRVTypeInst TypeDef = ST.getSPIRVGlobalRegistry()->getResultType(
2584 Reqs.
addCapability(SPIRV::Capability::StorageImageReadWithoutFormat);
2587 case SPIRV::OpImageWrite: {
2588 Register ImageReg =
MI.getOperand(0).getReg();
2589 SPIRVTypeInst TypeDef = ST.getSPIRVGlobalRegistry()->getResultType(
2598 Reqs.
addCapability(SPIRV::Capability::StorageImageWriteWithoutFormat);
2601 case SPIRV::OpTypeStructContinuedINTEL:
2602 case SPIRV::OpConstantCompositeContinuedINTEL:
2603 case SPIRV::OpSpecConstantCompositeContinuedINTEL:
2604 case SPIRV::OpCompositeConstructContinuedINTEL: {
2605 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_long_composites))
2607 "Continued instructions require the "
2608 "following SPIR-V extension: SPV_INTEL_long_composites",
2610 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_long_composites);
2614 case SPIRV::OpArbitraryFloatEQALTERA:
2615 case SPIRV::OpArbitraryFloatGEALTERA:
2616 case SPIRV::OpArbitraryFloatGTALTERA:
2617 case SPIRV::OpArbitraryFloatLEALTERA:
2618 case SPIRV::OpArbitraryFloatLTALTERA:
2619 case SPIRV::OpArbitraryFloatCbrtALTERA:
2620 case SPIRV::OpArbitraryFloatCosALTERA:
2621 case SPIRV::OpArbitraryFloatCosPiALTERA:
2622 case SPIRV::OpArbitraryFloatExp10ALTERA:
2623 case SPIRV::OpArbitraryFloatExp2ALTERA:
2624 case SPIRV::OpArbitraryFloatExpALTERA:
2625 case SPIRV::OpArbitraryFloatExpm1ALTERA:
2626 case SPIRV::OpArbitraryFloatHypotALTERA:
2627 case SPIRV::OpArbitraryFloatLog10ALTERA:
2628 case SPIRV::OpArbitraryFloatLog1pALTERA:
2629 case SPIRV::OpArbitraryFloatLog2ALTERA:
2630 case SPIRV::OpArbitraryFloatLogALTERA:
2631 case SPIRV::OpArbitraryFloatRecipALTERA:
2632 case SPIRV::OpArbitraryFloatSinCosALTERA:
2633 case SPIRV::OpArbitraryFloatSinCosPiALTERA:
2634 case SPIRV::OpArbitraryFloatSinALTERA:
2635 case SPIRV::OpArbitraryFloatSinPiALTERA:
2636 case SPIRV::OpArbitraryFloatSqrtALTERA:
2637 case SPIRV::OpArbitraryFloatACosALTERA:
2638 case SPIRV::OpArbitraryFloatACosPiALTERA:
2639 case SPIRV::OpArbitraryFloatAddALTERA:
2640 case SPIRV::OpArbitraryFloatASinALTERA:
2641 case SPIRV::OpArbitraryFloatASinPiALTERA:
2642 case SPIRV::OpArbitraryFloatATan2ALTERA:
2643 case SPIRV::OpArbitraryFloatATanALTERA:
2644 case SPIRV::OpArbitraryFloatATanPiALTERA:
2645 case SPIRV::OpArbitraryFloatCastFromIntALTERA:
2646 case SPIRV::OpArbitraryFloatCastALTERA:
2647 case SPIRV::OpArbitraryFloatCastToIntALTERA:
2648 case SPIRV::OpArbitraryFloatDivALTERA:
2649 case SPIRV::OpArbitraryFloatMulALTERA:
2650 case SPIRV::OpArbitraryFloatPowALTERA:
2651 case SPIRV::OpArbitraryFloatPowNALTERA:
2652 case SPIRV::OpArbitraryFloatPowRALTERA:
2653 case SPIRV::OpArbitraryFloatRSqrtALTERA:
2654 case SPIRV::OpArbitraryFloatSubALTERA: {
2655 if (!ST.canUseExtension(
2656 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_floating_point))
2658 "Floating point instructions can't be translated correctly without "
2659 "enabled SPV_ALTERA_arbitrary_precision_floating_point extension!",
2662 SPIRV::Extension::SPV_ALTERA_arbitrary_precision_floating_point);
2664 SPIRV::Capability::ArbitraryPrecisionFloatingPointALTERA);
2667 case SPIRV::OpSubgroupMatrixMultiplyAccumulateINTEL: {
2668 if (!ST.canUseExtension(
2669 SPIRV::Extension::SPV_INTEL_subgroup_matrix_multiply_accumulate))
2671 "OpSubgroupMatrixMultiplyAccumulateINTEL instruction requires the "
2673 "extension: SPV_INTEL_subgroup_matrix_multiply_accumulate",
2676 SPIRV::Extension::SPV_INTEL_subgroup_matrix_multiply_accumulate);
2678 SPIRV::Capability::SubgroupMatrixMultiplyAccumulateINTEL);
2681 case SPIRV::OpBitwiseFunctionINTEL: {
2682 if (!ST.canUseExtension(
2683 SPIRV::Extension::SPV_INTEL_ternary_bitwise_function))
2685 "OpBitwiseFunctionINTEL instruction requires the following SPIR-V "
2686 "extension: SPV_INTEL_ternary_bitwise_function",
2688 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_ternary_bitwise_function);
2689 Reqs.
addCapability(SPIRV::Capability::TernaryBitwiseFunctionINTEL);
2692 case SPIRV::OpCopyMemorySized: {
2697 case SPIRV::OpTypeUntypedPointerKHR:
2699 MI.getOperand(1).getImm(), ST);
2701 case SPIRV::OpUntypedVariableKHR:
2702 case SPIRV::OpUntypedAccessChainKHR:
2703 case SPIRV::OpUntypedInBoundsAccessChainKHR:
2704 case SPIRV::OpUntypedPtrAccessChainKHR:
2705 case SPIRV::OpUntypedInBoundsPtrAccessChainKHR:
2706 case SPIRV::OpUntypedPrefetchKHR:
2707 case SPIRV::OpUntypedGroupAsyncCopyKHR: {
2708 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_untyped_pointers))
2710 "SPIR-V extension: SPV_KHR_untyped_pointers",
2712 Reqs.
addExtension(SPIRV::Extension::SPV_KHR_untyped_pointers);
2716 case SPIRV::OpPredicatedLoadINTEL:
2717 case SPIRV::OpPredicatedStoreINTEL: {
2718 if (!ST.canUseExtension(SPIRV::Extension::SPV_INTEL_predicated_io))
2720 "OpPredicated[Load/Store]INTEL instructions require "
2721 "the following SPIR-V extension: SPV_INTEL_predicated_io",
2723 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_predicated_io);
2727 case SPIRV::OpFAddS:
2728 case SPIRV::OpFSubS:
2729 case SPIRV::OpFMulS:
2730 case SPIRV::OpFDivS:
2731 case SPIRV::OpFRemS:
2733 case SPIRV::OpFNegate:
2734 case SPIRV::OpFAddV:
2735 case SPIRV::OpFSubV:
2736 case SPIRV::OpFMulV:
2737 case SPIRV::OpFDivV:
2738 case SPIRV::OpFRemV:
2739 case SPIRV::OpFNegateV: {
2745 if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_bfloat16_arithmetic))
2747 "Arithmetic instructions with bfloat16 arguments require the "
2748 "following SPIR-V extension: SPV_EXT_bfloat16_arithmetic",
2750 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_bfloat16_arithmetic);
2751 Reqs.
addCapability(SPIRV::Capability::BFloat16ArithmeticEXT);
2755 case SPIRV::OpOrdered:
2756 case SPIRV::OpUnordered:
2757 case SPIRV::OpFOrdEqual:
2758 case SPIRV::OpFOrdNotEqual:
2759 case SPIRV::OpFOrdLessThan:
2760 case SPIRV::OpFOrdLessThanEqual:
2761 case SPIRV::OpFOrdGreaterThan:
2762 case SPIRV::OpFOrdGreaterThanEqual:
2763 case SPIRV::OpFUnordEqual:
2764 case SPIRV::OpFUnordNotEqual:
2765 case SPIRV::OpFUnordLessThan:
2766 case SPIRV::OpFUnordLessThanEqual:
2767 case SPIRV::OpFUnordGreaterThan:
2768 case SPIRV::OpFUnordGreaterThanEqual: {
2771 ST.getSPIRVGlobalRegistry());
2772 assert(TypeDef &&
"Unexpected type instruction for comparison operand");
2776 if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_bfloat16_arithmetic))
2778 "Relational instructions with bfloat16 arguments require the "
2779 "following SPIR-V extension: SPV_EXT_bfloat16_arithmetic",
2781 Reqs.
addExtension(SPIRV::Extension::SPV_EXT_bfloat16_arithmetic);
2782 Reqs.
addCapability(SPIRV::Capability::BFloat16ArithmeticEXT);
2786 case SPIRV::OpDPdxCoarse:
2787 case SPIRV::OpDPdyCoarse:
2788 case SPIRV::OpDPdxFine:
2789 case SPIRV::OpDPdyFine: {
2793 case SPIRV::OpLoopControlINTEL: {
2794 Reqs.
addExtension(SPIRV::Extension::SPV_INTEL_unstructured_loop_controls);
2795 Reqs.
addCapability(SPIRV::Capability::UnstructuredLoopControlsINTEL);
2807 SPIRV::Capability::Shader);
2822 auto Node = M.getNamedMetadata(
"spirv.ExecutionMode");
2824 bool RequireFloatControls =
false, RequireIntelFloatControls2 =
false,
2825 RequireKHRFloatControls2 =
false,
2826 VerLower14 = !ST.isAtLeastSPIRVVer(
VersionTuple(1, 4));
2827 bool HasIntelFloatControls2 =
2828 ST.canUseExtension(SPIRV::Extension::SPV_INTEL_float_controls2);
2829 bool HasKHRFloatControls2 =
2830 ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2);
2831 for (
unsigned i = 0; i <
Node->getNumOperands(); i++) {
2837 auto EM = Const->getZExtValue();
2841 case SPIRV::ExecutionMode::DenormPreserve:
2842 case SPIRV::ExecutionMode::DenormFlushToZero:
2843 case SPIRV::ExecutionMode::RoundingModeRTE:
2844 case SPIRV::ExecutionMode::RoundingModeRTZ:
2845 RequireFloatControls = VerLower14;
2847 SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
2849 case SPIRV::ExecutionMode::RoundingModeRTPINTEL:
2850 case SPIRV::ExecutionMode::RoundingModeRTNINTEL:
2851 case SPIRV::ExecutionMode::FloatingPointModeALTINTEL:
2852 case SPIRV::ExecutionMode::FloatingPointModeIEEEINTEL:
2853 if (HasIntelFloatControls2) {
2854 RequireIntelFloatControls2 =
true;
2856 SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
2859 case SPIRV::ExecutionMode::FPFastMathDefault: {
2860 if (HasKHRFloatControls2) {
2861 RequireKHRFloatControls2 =
true;
2863 SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
2867 case SPIRV::ExecutionMode::ContractionOff:
2868 case SPIRV::ExecutionMode::SignedZeroInfNanPreserve:
2869 if (HasKHRFloatControls2) {
2870 RequireKHRFloatControls2 =
true;
2872 SPIRV::OperandCategory::ExecutionModeOperand,
2873 SPIRV::ExecutionMode::FPFastMathDefault, ST);
2876 SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
2881 SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
2886 if (RequireFloatControls &&
2887 ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls))
2889 if (RequireIntelFloatControls2)
2891 if (RequireKHRFloatControls2)
2895 if (
F.isDeclaration())
2897 if (
F.getMetadata(
"reqd_work_group_size"))
2899 SPIRV::OperandCategory::ExecutionModeOperand,
2900 SPIRV::ExecutionMode::LocalSize, ST);
2901 if (
F.getFnAttribute(
"hlsl.numthreads").isValid()) {
2903 SPIRV::OperandCategory::ExecutionModeOperand,
2904 SPIRV::ExecutionMode::LocalSize, ST);
2906 if (
F.getFnAttribute(
"enable-maximal-reconvergence").getValueAsBool()) {
2909 if (
F.getMetadata(
"work_group_size_hint"))
2911 SPIRV::OperandCategory::ExecutionModeOperand,
2912 SPIRV::ExecutionMode::LocalSizeHint, ST);
2913 if (
F.getMetadata(
"intel_reqd_sub_group_size") ||
2914 F.getMetadata(
"reqd_sub_group_size"))
2916 SPIRV::OperandCategory::ExecutionModeOperand,
2917 SPIRV::ExecutionMode::SubgroupSize, ST);
2918 if (
F.getMetadata(
"max_work_group_size"))
2920 SPIRV::OperandCategory::ExecutionModeOperand,
2921 SPIRV::ExecutionMode::MaxWorkgroupSizeINTEL, ST);
2922 if (
F.getMetadata(
"vec_type_hint"))
2924 SPIRV::OperandCategory::ExecutionModeOperand,
2925 SPIRV::ExecutionMode::VecTypeHint, ST);
2927 if (
F.hasOptNone()) {
2928 if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_optnone)) {
2931 }
else if (ST.canUseExtension(SPIRV::Extension::SPV_EXT_optnone)) {
2941 unsigned Flags = SPIRV::FPFastMathMode::None;
2942 bool CanUseKHRFloatControls2 =
2943 ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2);
2945 Flags |= SPIRV::FPFastMathMode::NotNaN;
2947 Flags |= SPIRV::FPFastMathMode::NotInf;
2949 Flags |= SPIRV::FPFastMathMode::NSZ;
2951 Flags |= SPIRV::FPFastMathMode::AllowRecip;
2953 Flags |= SPIRV::FPFastMathMode::AllowContract;
2955 if (CanUseKHRFloatControls2)
2963 Flags |= SPIRV::FPFastMathMode::NotNaN | SPIRV::FPFastMathMode::NotInf |
2964 SPIRV::FPFastMathMode::NSZ | SPIRV::FPFastMathMode::AllowRecip |
2965 SPIRV::FPFastMathMode::AllowTransform |
2966 SPIRV::FPFastMathMode::AllowReassoc |
2967 SPIRV::FPFastMathMode::AllowContract;
2969 Flags |= SPIRV::FPFastMathMode::Fast;
2972 if (CanUseKHRFloatControls2) {
2974 assert(!(Flags & SPIRV::FPFastMathMode::Fast) &&
2975 "SPIRV::FPFastMathMode::Fast is deprecated and should not be used "
2980 assert((!(Flags & SPIRV::FPFastMathMode::AllowTransform) ||
2981 ((Flags & SPIRV::FPFastMathMode::AllowReassoc &&
2982 Flags & SPIRV::FPFastMathMode::AllowContract))) &&
2983 "SPIRV::FPFastMathMode::AllowTransform requires AllowReassoc and "
2984 "AllowContract flags to be enabled as well.");
2995 return ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2);
3005 auto Decorate = [&](SPIRV::Decoration::Decoration Dec,
3012 if (
TII.canUseIntegerWrapDecoration(
I)) {
3015 SPIRV::OperandCategory::DecorationOperand,
3016 SPIRV::Decoration::NoSignedWrap, ST, Reqs)
3018 Decorate(SPIRV::Decoration::NoSignedWrap, {});
3021 SPIRV::OperandCategory::DecorationOperand,
3022 SPIRV::Decoration::NoUnsignedWrap, ST, Reqs)
3024 Decorate(SPIRV::Decoration::NoUnsignedWrap, {});
3029 TII.canUseFastMathFlags(
3030 I, ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2)) ||
3031 (ST.isKernel() &&
I.getOpcode() == SPIRV::OpExtInst);
3036 if (FMFlags == SPIRV::FPFastMathMode::None) {
3039 if (FPFastMathDefaultInfoVec.
empty())
3045 I.getOpcode() == SPIRV::OpExtInst ||
3046 I.getOpcode() == SPIRV::OpFunctionCall
3047 ?
I.getMF()->getRegInfo().getVRegDef(
I.getOperand(1).getReg())
3048 :
getRegType(
I.getOperand(2).getReg(), *
I.getMF(), GR);
3055 if (Ty == Elem.Ty) {
3056 FMFlags = Elem.FastMathFlags;
3057 Emit = Elem.ContractionOff || Elem.SignedZeroInfNanPreserve ||
3058 Elem.FPFastMathDefault;
3063 if (FMFlags == SPIRV::FPFastMathMode::None && !Emit)
3067 Decorate(SPIRV::Decoration::FPFastMathMode, {FMFlags});
3081 for (
const auto &
MBB : *MF) {
3082 if (!
MBB.hasName() ||
MBB.empty())
3093 auto it = FPFastMathDefaultInfoMap.
find(
F);
3094 if (it != FPFastMathDefaultInfoMap.
end())
3102 SPIRV::FPFastMathMode::None);
3104 SPIRV::FPFastMathMode::None);
3106 SPIRV::FPFastMathMode::None);
3107 return FPFastMathDefaultInfoMap[
F] = std::move(FPFastMathDefaultInfoVec);
3113 size_t BitWidth = Ty->getScalarSizeInBits();
3117 assert(Index >= 0 && Index < 3 &&
3118 "Expected FPFastMathDefaultInfo for half, float, or double");
3119 assert(FPFastMathDefaultInfoVec.
size() == 3 &&
3120 "Expected FPFastMathDefaultInfoVec to have exactly 3 elements");
3121 return FPFastMathDefaultInfoVec[Index];
3128 if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls2))
3137 auto Node = M.getNamedMetadata(
"spirv.ExecutionMode");
3141 for (
unsigned i = 0; i <
Node->getNumOperands(); i++) {
3146 if (OnlyF &&
F != OnlyF)
3152 if (EM == SPIRV::ExecutionMode::FPFastMathDefault) {
3154 "Expected 4 operands for FPFastMathDefault");
3165 Info.FastMathFlags = Flags;
3166 Info.FPFastMathDefault =
true;
3167 }
else if (EM == SPIRV::ExecutionMode::ContractionOff) {
3169 "Expected no operands for ContractionOff");
3176 Info.ContractionOff =
true;
3178 }
else if (EM == SPIRV::ExecutionMode::SignedZeroInfNanPreserve) {
3180 "Expected 1 operand for SignedZeroInfNanPreserve");
3181 unsigned TargetWidth =
3190 assert(Index >= 0 && Index < 3 &&
3191 "Expected FPFastMathDefaultInfo for half, float, or double");
3192 assert(FPFastMathDefaultInfoVec.
size() == 3 &&
3193 "Expected FPFastMathDefaultInfoVec to have exactly 3 elements");
3194 FPFastMathDefaultInfoVec[Index].SignedZeroInfNanPreserve =
true;
3202 : ST(&ST), GR(ST.getSPIRVGlobalRegistry()), TII(ST.getInstrInfo()),
3203 MAI(MAI), GetMF(GetMF) {}
3215 collectDeclarations(M);
3218 numberRegistersGlobally(M);
3221 processOtherInstrs(M);
3225 MAI.Reqs.addCapability(SPIRV::Capability::Linkage);
3228 GR->setBound(MAI.MaxID);
3242 [&MMI](
const Function &
F) { return MMI.getMachineFunction(F); })
3258 MachineFunctionAnalysis::Result *MFA =
3259 FAM.getCachedResult<MachineFunctionAnalysis>(
3260 const_cast<Function &>(F));
3261 assert((MFA || F.isDeclaration()) &&
3262 "Missing MachineFunction for definition");
3263 return MFA ? &MFA->getMF() : nullptr;
3280 for (
auto &
MBB : MF)
3283 FPFastMathDefaultInfoMap[&
F]);
3291 SPIRVPrepareModuleAnalysisLegacy() : MachineFunctionPass(
ID) {}
3298char SPIRVPrepareModuleAnalysisLegacy::ID = 0;
3301 "spirv-prepare-module-analysis",
3302 "SPIRV prepare module analysis",
false,
false)
3305 return new SPIRVPrepareModuleAnalysisLegacy();
MachineInstrBuilder & UseMI
MachineInstrBuilder MachineInstrBuilder & DefMI
const AArch64Subtarget & Subtarget
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
const AArch64InstrInfo MachineBasicBlock::iterator InsertPt
const AArch64InstrInfo & TII
ReachingDefInfo InstSet & ToRemove
static GCRegistry::Add< ShadowStackGC > C("shadow-stack", "Very portable GC for uncooperative code generators")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
static Register UseReg(const MachineOperand &MO)
Promote Memory to Register
FunctionAnalysisManager FAM
ModuleAnalysisManager MAM
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
MachineRegisterInfo & MRI
#define ATOM_FLT_REQ_EXT_MSG(ExtName)
static bool isFastMathModeAvailable(const SPIRVSubtarget &ST)
static void addMBBNames(const Module &M, MachineFunctionGetter GetMF, SPIRV::ModuleAnalysisInfo &MAI)
static void maybeAddScatterGatherReq(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static void addImageOperandReqs(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST, unsigned OpIdx)
bool isStorageImage(MachineInstr *ImageInst)
bool isInputAttachment(MachineInstr *ImageInst)
static bool isBFloat16Type(SPIRVTypeInst TypeDef)
static bool handleMIFlagDecoration(MachineInstr &I, const SPIRVSubtarget &ST, const SPIRVInstrInfo &TII, SPIRV::RequirementHandler &Reqs, const SPIRVGlobalRegistry *GR, SPIRV::FPFastMathDefaultInfoVector &FPFastMathDefaultInfoVec)
bool isSampledImage(MachineInstr *ImageInst)
static unsigned getInvokeOperandIdx(unsigned Opcode)
static SPIRV::FPFastMathDefaultInfo & getFPFastMathDefaultInfo(SPIRV::FPFastMathDefaultInfoVector &FPFastMathDefaultInfoVec, const Type *Ty)
static void collectFPFastMathDefaults(const Module &M, SPIRV::FPFastMathDefaultInfoMapTy &FPFastMathDefaultInfoMap, const SPIRVSubtarget &ST, const Function *OnlyF=nullptr)
static void collectOtherInstr(MachineInstr &MI, SPIRV::ModuleAnalysisInfo &MAI, SPIRV::ModuleSectionType MSType, InstrTraces &IS, bool Append=true)
void addPrintfRequirements(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static void addOpTypeImageReqs(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static void addQuadControlRequirements(SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST, StringRef Feature)
static bool isImageTypeWithUnknownFormat(SPIRVTypeInst TypeInst)
bool isUniformTexelBuffer(MachineInstr *ImageInst)
bool isStorageTexelBuffer(MachineInstr *ImageInst)
static void AddAtomicFloatRequirements(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
bool isCombinedImageSampler(MachineInstr *SampledImageInst)
bool hasNonUniformDecoration(Register Reg, const MachineRegisterInfo &MRI)
void addInstrRequirements(const MachineInstr &MI, SPIRV::ModuleAnalysisInfo &MAI, const SPIRVSubtarget &ST)
static void collectReqs(const Module &M, SPIRV::ModuleAnalysisInfo &MAI, MachineFunctionGetter GetMF, const SPIRVSubtarget &ST)
static void addOpDecorateReqs(const MachineInstr &MI, unsigned DecIndex, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static InstrSignature instrToSignature(const MachineInstr &MI, SPIRV::ModuleAnalysisInfo &MAI, bool UseDefReg)
static void AddDotProductRequirements(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static SPIRV::Requirements getSymbolicOperandRequirements(SPIRV::OperandCategory::OperandCategory Category, unsigned i, const SPIRVSubtarget &ST, SPIRV::RequirementHandler &Reqs)
static SPIRVTypeInst getRegType(Register Reg, const MachineFunction &MF, const SPIRVGlobalRegistry *GR)
static unsigned getMetadataUInt(MDNode *MdNode, unsigned OpIndex, unsigned DefaultVal=0)
static void addCoreInSPIRV13Capability(SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST, SPIRV::Capability::Capability Cap, SPIRV::Extension::Extension Ext)
void addOpAccessChainReqs(const MachineInstr &Instr, SPIRV::RequirementHandler &Handler, const SPIRVSubtarget &Subtarget)
static bool prepareModuleAnalysis(MachineFunction &MF)
static void appendDecorationsForReg(const MachineRegisterInfo &MRI, Register R, InstrSignature &Signature)
static SPIRV::FPFastMathDefaultInfoVector & getOrCreateFPFastMathDefaultInfoVec(const Module &M, SPIRV::FPFastMathDefaultInfoMapTy &FPFastMathDefaultInfoMap, const Function *F)
static bool shouldAvoidCapability(const SPIRVSubtarget &ST, SPIRV::Capability::Capability Cap)
static void AddAtomicVectorFloatRequirements(const MachineInstr &MI, SPIRV::RequirementHandler &Reqs, const SPIRVSubtarget &ST)
static unsigned getFastMathFlags(const MachineInstr &I, const SPIRVSubtarget &ST)
#define SPIRV_BACKEND_SERVICE_FUN_NAME
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
Target-Independent Code Generator Pass Configuration Options pass.
static Function * getFunction(FunctionType *Ty, const Twine &Name, Module *M)
Represent the analysis usage information of a pass.
AnalysisUsage & addRequired()
Represent a constant reference to an array (0 or more elements consecutively in memory),...
bool isValid() const
Return true if the attribute is any kind of attribute.
This is the shared class of boolean and integer constants.
This is an important base class in LLVM.
Diagnostic information for unsupported feature in backend.
FunctionPass class - This class is used to implement most global optimizations.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
Wrapper class representing physical registers. Should be passed by value.
constexpr bool isValid() const
const MDOperand & getOperand(unsigned I) const
unsigned getNumOperands() const
Return number of MDNode operands.
Tracking metadata reference owned by Metadata.
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
MachineInstrBundleIterator< MachineInstr > iterator
MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Function & getFunction()
Return the LLVM function that this machine code represents.
Helper class to build MachineInstr.
void setDebugLoc(const DebugLoc &DL)
Set the debug location to DL for all the next build instructions.
Register getReg(unsigned Idx) const
Get the register for the operand index.
Representation of each machine instruction.
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
const MachineBasicBlock * getParent() const
unsigned getNumOperands() const
Retuns the total number of operands.
LLVM_ABI const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
const MachineOperand & getOperand(unsigned i) const
An analysis that produces MachineModuleInfo for a module.
This class contains meta information specific to a module.
MachineOperand class - Representation of each machine instruction operand.
unsigned getSubReg() const
bool isReg() const
isReg - Tests if this is a MO_Register operand.
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
LLVM_ABI void print(raw_ostream &os, const TargetRegisterInfo *TRI=nullptr) const
Print the MachineOperand to os.
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
static MachineOperand CreateImm(int64_t Val)
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
Register getReg() const
getReg - Returns the register number.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
const TargetRegisterClass * getRegClass(Register Reg) const
Return the register class of the specified virtual register.
iterator_range< use_instr_iterator > use_instructions(Register Reg) const
LLVM_ABI LLVM_READONLY MachineInstr * getUniqueVRegDef(Register Reg) const
getUniqueVRegDef - Return the unique machine instr that defines the specified virtual register or nul...
iterator find(const KeyT &Key)
A Module instance is used to store all the information related to an LLVM module.
AnalysisType & getAnalysis() const
getAnalysis<AnalysisType>() - This function is used by subclasses to get to the analysis information ...
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Wrapper class representing virtual and physical registers.
constexpr bool isValid() const
unsigned getScalarOrVectorBitWidth(SPIRVTypeInst Type) const
SPIRVTypeInst getResultType(Register VReg, MachineFunction *MF=nullptr)
const Type * getTypeForSPIRVType(SPIRVTypeInst Ty) const
SPIRVTypeInst getSPIRVTypeForVReg(Register VReg, const MachineFunction *MF=nullptr) const
void run(const Module &M)
SPIRVModuleAnalysisImpl(const SPIRVSubtarget &ST, SPIRV::ModuleAnalysisInfo &MAI, MachineFunctionGetter GetMF)
SPIRV::ModuleAnalysisInfo Result
Result run(Module &M, ModuleAnalysisManager &MAM)
PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)
const SPIRVSubtarget * getSubtargetImpl() const
reference emplace_back(ArgTypes &&... Args)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
iterator insert(iterator I, T &&Elt)
void push_back(const T &Elt)
LLVM_NO_SANITIZE_CFI_UNRELATED_CAST iterator begin()
Represent a constant reference to a string, i.e.
Target-Independent Code Generator Pass Configuration Options.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isVectorTy() const
True if this is an instance of VectorType.
static LLVM_ABI Type * getDoubleTy(LLVMContext &C)
static LLVM_ABI Type * getFloatTy(LLVMContext &C)
static LLVM_ABI Type * getHalfTy(LLVMContext &C)
Represents a version number in the form major[.minor[.subminor[.build]]].
bool empty() const
Determine whether this version information is empty (e.g., all version components are zero).
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
MapVector< const Function *, FPFastMathDefaultInfoVector > FPFastMathDefaultInfoMapTy
SmallVector< const MachineInstr * > InstrList
std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)
Extract a Value from Metadata.
This is an optimization pass for GlobalISel generic memory operations.
void stable_sort(R &&Range)
std::string getStringImm(const MachineInstr &MI, unsigned StartIndex)
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
hash_code hash_value(const FixedPointSemantics &Val)
ExtensionList getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
CapabilityList getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
SmallVector< SPIRV::Extension::Extension, 8 > ExtensionList
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
SmallVector< size_t > InstrSignature
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
InnerAnalysisManagerProxy< FunctionAnalysisManager, Module > FunctionAnalysisManagerModuleProxy
Provide the FunctionAnalysisManager to Module proxy.
static void reportUnsupported(MachineIRBuilder &MIRBuilder, const Twine &Msg)
AnalysisManager< MachineFunction > MachineFunctionAnalysisManager
void buildOpDecorate(Register Reg, MachineIRBuilder &MIRBuilder, SPIRV::Decoration::Decoration Dec, ArrayRef< uint32_t > DecArgs, StringRef StrImm)
bool isVectorType(SPIRVTypeInst SPVTy)
RelativeUniformCounterPtr ValuesPtrExpr VTableAddr Value
LLVM_ABI PreservedAnalyses getMachineFunctionPassPreservedAnalyses()
Returns the minimum set of Analyses that all machine function passes must preserve.
VersionTuple getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
function_ref< MachineFunction *(const Function &)> MachineFunctionGetter
void erase(Container &C, ValueType V)
Wrapper function to remove a value from a container:
MachineInstr * getImm(const MachineOperand &MO, const MachineRegisterInfo *MRI)
CapabilityList getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension)
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
FunctionPass * createSPIRVPrepareModuleAnalysisLegacyPass()
std::string getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category, int32_t Value)
LLVM_ABI raw_fd_ostream & errs()
This returns a reference to a raw_ostream for standard error.
bool requiresLongVectorEXT(unsigned NumComponents, bool CanUseVector16=true)
DWARFExpression::Operation Op
VersionTuple getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category, uint32_t Value)
constexpr unsigned BitWidth
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
bool is_contained(R &&Range, const E &Element)
Returns true if Element is found in Range.
SmallVector< SPIRV::Capability::Capability, 8 > CapabilityList
std::set< InstrSignature > InstrTraces
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
std::map< SmallVector< size_t >, unsigned > InstrGRegsMap
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
LLVM_ABI void reportFatalUsageError(Error Err)
Report a fatal error that does not indicate a bug in LLVM.
A special type used by analysis passes to provide an address that identifies that particular analysis...
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
SPIRV::ModuleAnalysisInfo MAI
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
static size_t computeFPFastMathDefaultInfoVecIndex(size_t BitWidth)
void setSkipEmission(const MachineInstr *MI)
MCRegister getRegisterAlias(const MachineFunction *MF, Register Reg)
MCRegister getOrCreateMBBRegister(const MachineBasicBlock &MBB)
InstrList MS[NUM_MODULE_SECTIONS]
AddressingModel::AddressingModel Addr
SmallVector< std::pair< MCRegister, StringRef > > MBBNames
void checkSatisfiable(const SPIRVSubtarget &ST) const
void getAndAddRequirements(SPIRV::OperandCategory::OperandCategory Category, uint32_t i, const SPIRVSubtarget &ST)
void addRequirements(const Requirements &Req)
bool isCapabilityAvailable(Capability::Capability Cap) const
void removeCapabilityIf(const Capability::Capability ToRemove, const Capability::Capability IfPresent)
void addExtensions(const ExtensionList &ToAdd)
void addAvailableCaps(const CapabilityList &ToAdd)
void addExtension(Extension::Extension ToAdd)
void initAvailableCapabilities(const SPIRVSubtarget &ST)
void addCapability(Capability::Capability ToAdd)
void addCapabilities(const CapabilityList &ToAdd)
const std::optional< Capability::Capability > Cap
const VersionTuple MinVer
const VersionTuple MaxVer