xref: /llvm-project/llvm/lib/Target/SPIRV/SPIRVModuleAnalysis.cpp (revision f99bb02d7d28bb127af86483d9c2710088f76756) 
1 //===- SPIRVModuleAnalysis.cpp - analysis of global instrs & regs - C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // The analysis collects instructions that should be output at the module level
10 // and performs the global register numbering.
11 //
12 // The results of this analysis are used in AsmPrinter to rename registers
13 // globally and to output required instructions at the module level.
14 //
15 //===----------------------------------------------------------------------===//
16 
17 #include "SPIRVModuleAnalysis.h"
18 #include "MCTargetDesc/SPIRVBaseInfo.h"
19 #include "MCTargetDesc/SPIRVMCTargetDesc.h"
20 #include "SPIRV.h"
21 #include "SPIRVSubtarget.h"
22 #include "SPIRVTargetMachine.h"
23 #include "SPIRVUtils.h"
24 #include "llvm/ADT/STLExtras.h"
25 #include "llvm/CodeGen/MachineModuleInfo.h"
26 #include "llvm/CodeGen/TargetPassConfig.h"
27 
28 using namespace llvm;
29 
30 #define DEBUG_TYPE "spirv-module-analysis"
31 
32 static cl::opt<bool>
33     SPVDumpDeps("spv-dump-deps",
34                 cl::desc("Dump MIR with SPIR-V dependencies info"),
35                 cl::Optional, cl::init(false));
36 
37 static cl::list<SPIRV::Capability::Capability>
38     AvoidCapabilities("avoid-spirv-capabilities",
39                       cl::desc("SPIR-V capabilities to avoid if there are "
40                                "other options enabling a feature"),
41                       cl::ZeroOrMore, cl::Hidden,
42                       cl::values(clEnumValN(SPIRV::Capability::Shader, "Shader",
43                                             "SPIR-V Shader capability")));
44 // Use sets instead of cl::list to check "if contains" condition
45 struct AvoidCapabilitiesSet {
46   SmallSet<SPIRV::Capability::Capability, 4> S;
47   AvoidCapabilitiesSet() {
48     for (auto Cap : AvoidCapabilities)
49       S.insert(Cap);
50   }
51 };
52 
53 char llvm::SPIRVModuleAnalysis::ID = 0;
54 
55 namespace llvm {
56 void initializeSPIRVModuleAnalysisPass(PassRegistry &);
57 } // namespace llvm
58 
59 INITIALIZE_PASS(SPIRVModuleAnalysis, DEBUG_TYPE, "SPIRV module analysis", true,
60                 true)
61 
62 // Retrieve an unsigned from an MDNode with a list of them as operands.
63 static unsigned getMetadataUInt(MDNode *MdNode, unsigned OpIndex,
64                                 unsigned DefaultVal = 0) {
65   if (MdNode && OpIndex < MdNode->getNumOperands()) {
66     const auto &Op = MdNode->getOperand(OpIndex);
67     return mdconst::extract<ConstantInt>(Op)->getZExtValue();
68   }
69   return DefaultVal;
70 }
71 
72 static SPIRV::Requirements
73 getSymbolicOperandRequirements(SPIRV::OperandCategory::OperandCategory Category,
74                                unsigned i, const SPIRVSubtarget &ST,
75                                SPIRV::RequirementHandler &Reqs) {
76   static AvoidCapabilitiesSet
77       AvoidCaps; // contains capabilities to avoid if there is another option
78 
79   VersionTuple ReqMinVer = getSymbolicOperandMinVersion(Category, i);
80   VersionTuple ReqMaxVer = getSymbolicOperandMaxVersion(Category, i);
81   VersionTuple SPIRVVersion = ST.getSPIRVVersion();
82   bool MinVerOK = SPIRVVersion.empty() || SPIRVVersion >= ReqMinVer;
83   bool MaxVerOK =
84       ReqMaxVer.empty() || SPIRVVersion.empty() || SPIRVVersion <= ReqMaxVer;
85   CapabilityList ReqCaps = getSymbolicOperandCapabilities(Category, i);
86   ExtensionList ReqExts = getSymbolicOperandExtensions(Category, i);
87   if (ReqCaps.empty()) {
88     if (ReqExts.empty()) {
89       if (MinVerOK && MaxVerOK)
90         return {true, {}, {}, ReqMinVer, ReqMaxVer};
91       return {false, {}, {}, VersionTuple(), VersionTuple()};
92     }
93   } else if (MinVerOK && MaxVerOK) {
94     if (ReqCaps.size() == 1) {
95       auto Cap = ReqCaps[0];
96       if (Reqs.isCapabilityAvailable(Cap))
97         return {true, {Cap}, ReqExts, ReqMinVer, ReqMaxVer};
98     } else {
99       // By SPIR-V specification: "If an instruction, enumerant, or other
100       // feature specifies multiple enabling capabilities, only one such
101       // capability needs to be declared to use the feature." However, one
102       // capability may be preferred over another. We use command line
103       // argument(s) and AvoidCapabilities to avoid selection of certain
104       // capabilities if there are other options.
105       CapabilityList UseCaps;
106       for (auto Cap : ReqCaps)
107         if (Reqs.isCapabilityAvailable(Cap))
108           UseCaps.push_back(Cap);
109       for (size_t i = 0, Sz = UseCaps.size(); i < Sz; ++i) {
110         auto Cap = UseCaps[i];
111         if (i == Sz - 1 || !AvoidCaps.S.contains(Cap))
112           return {true, {Cap}, ReqExts, ReqMinVer, ReqMaxVer};
113       }
114     }
115   }
116   // If there are no capabilities, or we can't satisfy the version or
117   // capability requirements, use the list of extensions (if the subtarget
118   // can handle them all).
119   if (llvm::all_of(ReqExts, [&ST](const SPIRV::Extension::Extension &Ext) {
120         return ST.canUseExtension(Ext);
121       })) {
122     return {true,
123             {},
124             ReqExts,
125             VersionTuple(),
126             VersionTuple()}; // TODO: add versions to extensions.
127   }
128   return {false, {}, {}, VersionTuple(), VersionTuple()};
129 }
130 
131 void SPIRVModuleAnalysis::setBaseInfo(const Module &M) {
132   MAI.MaxID = 0;
133   for (int i = 0; i < SPIRV::NUM_MODULE_SECTIONS; i++)
134     MAI.MS[i].clear();
135   MAI.RegisterAliasTable.clear();
136   MAI.InstrsToDelete.clear();
137   MAI.FuncMap.clear();
138   MAI.GlobalVarList.clear();
139   MAI.ExtInstSetMap.clear();
140   MAI.Reqs.clear();
141   MAI.Reqs.initAvailableCapabilities(*ST);
142 
143   // TODO: determine memory model and source language from the configuratoin.
144   if (auto MemModel = M.getNamedMetadata("spirv.MemoryModel")) {
145     auto MemMD = MemModel->getOperand(0);
146     MAI.Addr = static_cast<SPIRV::AddressingModel::AddressingModel>(
147         getMetadataUInt(MemMD, 0));
148     MAI.Mem =
149         static_cast<SPIRV::MemoryModel::MemoryModel>(getMetadataUInt(MemMD, 1));
150   } else {
151     // TODO: Add support for VulkanMemoryModel.
152     MAI.Mem = ST->isOpenCLEnv() ? SPIRV::MemoryModel::OpenCL
153                                 : SPIRV::MemoryModel::GLSL450;
154     if (MAI.Mem == SPIRV::MemoryModel::OpenCL) {
155       unsigned PtrSize = ST->getPointerSize();
156       MAI.Addr = PtrSize == 32   ? SPIRV::AddressingModel::Physical32
157                  : PtrSize == 64 ? SPIRV::AddressingModel::Physical64
158                                  : SPIRV::AddressingModel::Logical;
159     } else {
160       // TODO: Add support for PhysicalStorageBufferAddress.
161       MAI.Addr = SPIRV::AddressingModel::Logical;
162     }
163   }
164   // Get the OpenCL version number from metadata.
165   // TODO: support other source languages.
166   if (auto VerNode = M.getNamedMetadata("opencl.ocl.version")) {
167     MAI.SrcLang = SPIRV::SourceLanguage::OpenCL_C;
168     // Construct version literal in accordance with SPIRV-LLVM-Translator.
169     // TODO: support multiple OCL version metadata.
170     assert(VerNode->getNumOperands() > 0 && "Invalid SPIR");
171     auto VersionMD = VerNode->getOperand(0);
172     unsigned MajorNum = getMetadataUInt(VersionMD, 0, 2);
173     unsigned MinorNum = getMetadataUInt(VersionMD, 1);
174     unsigned RevNum = getMetadataUInt(VersionMD, 2);
175     // Prevent Major part of OpenCL version to be 0
176     MAI.SrcLangVersion =
177         (std::max(1U, MajorNum) * 100 + MinorNum) * 1000 + RevNum;
178   } else {
179     // If there is no information about OpenCL version we are forced to generate
180     // OpenCL 1.0 by default for the OpenCL environment to avoid puzzling
181     // run-times with Unknown/0.0 version output. For a reference, LLVM-SPIRV
182     // Translator avoids potential issues with run-times in a similar manner.
183     if (ST->isOpenCLEnv()) {
184       MAI.SrcLang = SPIRV::SourceLanguage::OpenCL_CPP;
185       MAI.SrcLangVersion = 100000;
186     } else {
187       MAI.SrcLang = SPIRV::SourceLanguage::Unknown;
188       MAI.SrcLangVersion = 0;
189     }
190   }
191 
192   if (auto ExtNode = M.getNamedMetadata("opencl.used.extensions")) {
193     for (unsigned I = 0, E = ExtNode->getNumOperands(); I != E; ++I) {
194       MDNode *MD = ExtNode->getOperand(I);
195       if (!MD || MD->getNumOperands() == 0)
196         continue;
197       for (unsigned J = 0, N = MD->getNumOperands(); J != N; ++J)
198         MAI.SrcExt.insert(cast<MDString>(MD->getOperand(J))->getString());
199     }
200   }
201 
202   // Update required capabilities for this memory model, addressing model and
203   // source language.
204   MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::MemoryModelOperand,
205                                  MAI.Mem, *ST);
206   MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::SourceLanguageOperand,
207                                  MAI.SrcLang, *ST);
208   MAI.Reqs.getAndAddRequirements(SPIRV::OperandCategory::AddressingModelOperand,
209                                  MAI.Addr, *ST);
210 
211   if (ST->isOpenCLEnv()) {
212     // TODO: check if it's required by default.
213     MAI.ExtInstSetMap[static_cast<unsigned>(
214         SPIRV::InstructionSet::OpenCL_std)] =
215         Register::index2VirtReg(MAI.getNextID());
216   }
217 }
218 
219 // Collect MI which defines the register in the given machine function.
220 static void collectDefInstr(Register Reg, const MachineFunction *MF,
221                             SPIRV::ModuleAnalysisInfo *MAI,
222                             SPIRV::ModuleSectionType MSType,
223                             bool DoInsert = true) {
224   assert(MAI->hasRegisterAlias(MF, Reg) && "Cannot find register alias");
225   MachineInstr *MI = MF->getRegInfo().getUniqueVRegDef(Reg);
226   assert(MI && "There should be an instruction that defines the register");
227   MAI->setSkipEmission(MI);
228   if (DoInsert)
229     MAI->MS[MSType].push_back(MI);
230 }
231 
232 void SPIRVModuleAnalysis::collectGlobalEntities(
233     const std::vector<SPIRV::DTSortableEntry *> &DepsGraph,
234     SPIRV::ModuleSectionType MSType,
235     std::function<bool(const SPIRV::DTSortableEntry *)> Pred,
236     bool UsePreOrder = false) {
237   DenseSet<const SPIRV::DTSortableEntry *> Visited;
238   for (const auto *E : DepsGraph) {
239     std::function<void(const SPIRV::DTSortableEntry *)> RecHoistUtil;
240     // NOTE: here we prefer recursive approach over iterative because
241     // we don't expect depchains long enough to cause SO.
242     RecHoistUtil = [MSType, UsePreOrder, &Visited, &Pred,
243                     &RecHoistUtil](const SPIRV::DTSortableEntry *E) {
244       if (Visited.count(E) || !Pred(E))
245         return;
246       Visited.insert(E);
247 
248       // Traversing deps graph in post-order allows us to get rid of
249       // register aliases preprocessing.
250       // But pre-order is required for correct processing of function
251       // declaration and arguments processing.
252       if (!UsePreOrder)
253         for (auto *S : E->getDeps())
254           RecHoistUtil(S);
255 
256       Register GlobalReg = Register::index2VirtReg(MAI.getNextID());
257       bool IsFirst = true;
258       for (auto &U : *E) {
259         const MachineFunction *MF = U.first;
260         Register Reg = U.second;
261         MAI.setRegisterAlias(MF, Reg, GlobalReg);
262         if (!MF->getRegInfo().getUniqueVRegDef(Reg))
263           continue;
264         collectDefInstr(Reg, MF, &MAI, MSType, IsFirst);
265         IsFirst = false;
266         if (E->getIsGV())
267           MAI.GlobalVarList.push_back(MF->getRegInfo().getUniqueVRegDef(Reg));
268       }
269 
270       if (UsePreOrder)
271         for (auto *S : E->getDeps())
272           RecHoistUtil(S);
273     };
274     RecHoistUtil(E);
275   }
276 }
277 
278 // The function initializes global register alias table for types, consts,
279 // global vars and func decls and collects these instruction for output
280 // at module level. Also it collects explicit OpExtension/OpCapability
281 // instructions.
282 void SPIRVModuleAnalysis::processDefInstrs(const Module &M) {
283   std::vector<SPIRV::DTSortableEntry *> DepsGraph;
284 
285   GR->buildDepsGraph(DepsGraph, SPVDumpDeps ? MMI : nullptr);
286 
287   collectGlobalEntities(
288       DepsGraph, SPIRV::MB_TypeConstVars,
289       [](const SPIRV::DTSortableEntry *E) { return !E->getIsFunc(); });
290 
291   for (auto F = M.begin(), E = M.end(); F != E; ++F) {
292     MachineFunction *MF = MMI->getMachineFunction(*F);
293     if (!MF)
294       continue;
295     // Iterate through and collect OpExtension/OpCapability instructions.
296     for (MachineBasicBlock &MBB : *MF) {
297       for (MachineInstr &MI : MBB) {
298         if (MI.getOpcode() == SPIRV::OpExtension) {
299           // Here, OpExtension just has a single enum operand, not a string.
300           auto Ext = SPIRV::Extension::Extension(MI.getOperand(0).getImm());
301           MAI.Reqs.addExtension(Ext);
302           MAI.setSkipEmission(&MI);
303         } else if (MI.getOpcode() == SPIRV::OpCapability) {
304           auto Cap = SPIRV::Capability::Capability(MI.getOperand(0).getImm());
305           MAI.Reqs.addCapability(Cap);
306           MAI.setSkipEmission(&MI);
307         }
308       }
309     }
310   }
311 
312   collectGlobalEntities(
313       DepsGraph, SPIRV::MB_ExtFuncDecls,
314       [](const SPIRV::DTSortableEntry *E) { return E->getIsFunc(); }, true);
315 }
316 
317 // Look for IDs declared with Import linkage, and map the corresponding function
318 // to the register defining that variable (which will usually be the result of
319 // an OpFunction). This lets us call externally imported functions using
320 // the correct ID registers.
321 void SPIRVModuleAnalysis::collectFuncNames(MachineInstr &MI,
322                                            const Function *F) {
323   if (MI.getOpcode() == SPIRV::OpDecorate) {
324     // If it's got Import linkage.
325     auto Dec = MI.getOperand(1).getImm();
326     if (Dec == static_cast<unsigned>(SPIRV::Decoration::LinkageAttributes)) {
327       auto Lnk = MI.getOperand(MI.getNumOperands() - 1).getImm();
328       if (Lnk == static_cast<unsigned>(SPIRV::LinkageType::Import)) {
329         // Map imported function name to function ID register.
330         const Function *ImportedFunc =
331             F->getParent()->getFunction(getStringImm(MI, 2));
332         Register Target = MI.getOperand(0).getReg();
333         MAI.FuncMap[ImportedFunc] = MAI.getRegisterAlias(MI.getMF(), Target);
334       }
335     }
336   } else if (MI.getOpcode() == SPIRV::OpFunction) {
337     // Record all internal OpFunction declarations.
338     Register Reg = MI.defs().begin()->getReg();
339     Register GlobalReg = MAI.getRegisterAlias(MI.getMF(), Reg);
340     assert(GlobalReg.isValid());
341     MAI.FuncMap[F] = GlobalReg;
342   }
343 }
344 
345 // References to a function via function pointers generate virtual
346 // registers without a definition. We are able to resolve this
347 // reference using Globar Register info into an OpFunction instruction
348 // and replace dummy operands by the corresponding global register references.
349 void SPIRVModuleAnalysis::collectFuncPtrs() {
350   for (auto &MI : MAI.MS[SPIRV::MB_TypeConstVars])
351     if (MI->getOpcode() == SPIRV::OpConstantFunctionPointerINTEL)
352       collectFuncPtrs(MI);
353 }
354 
355 void SPIRVModuleAnalysis::collectFuncPtrs(MachineInstr *MI) {
356   const MachineOperand *FunUse = &MI->getOperand(2);
357   if (const MachineOperand *FunDef = GR->getFunctionDefinitionByUse(FunUse)) {
358     const MachineInstr *FunDefMI = FunDef->getParent();
359     assert(FunDefMI->getOpcode() == SPIRV::OpFunction &&
360            "Constant function pointer must refer to function definition");
361     Register FunDefReg = FunDef->getReg();
362     Register GlobalFunDefReg =
363         MAI.getRegisterAlias(FunDefMI->getMF(), FunDefReg);
364     assert(GlobalFunDefReg.isValid() &&
365            "Function definition must refer to a global register");
366     Register FunPtrReg = FunUse->getReg();
367     MAI.setRegisterAlias(MI->getMF(), FunPtrReg, GlobalFunDefReg);
368   }
369 }
370 
371 using InstrSignature = SmallVector<size_t>;
372 using InstrTraces = std::set<InstrSignature>;
373 
374 // Returns a representation of an instruction as a vector of MachineOperand
375 // hash values, see llvm::hash_value(const MachineOperand &MO) for details.
376 // This creates a signature of the instruction with the same content
377 // that MachineOperand::isIdenticalTo uses for comparison.
378 static InstrSignature instrToSignature(MachineInstr &MI,
379                                        SPIRV::ModuleAnalysisInfo &MAI) {
380   InstrSignature Signature;
381   for (unsigned i = 0; i < MI.getNumOperands(); ++i) {
382     const MachineOperand &MO = MI.getOperand(i);
383     size_t h;
384     if (MO.isReg()) {
385       Register RegAlias = MAI.getRegisterAlias(MI.getMF(), MO.getReg());
386       // mimic llvm::hash_value(const MachineOperand &MO)
387       h = hash_combine(MO.getType(), (unsigned)RegAlias, MO.getSubReg(),
388                        MO.isDef());
389     } else {
390       h = hash_value(MO);
391     }
392     Signature.push_back(h);
393   }
394   return Signature;
395 }
396 
397 // Collect the given instruction in the specified MS. We assume global register
398 // numbering has already occurred by this point. We can directly compare reg
399 // arguments when detecting duplicates.
400 static void collectOtherInstr(MachineInstr &MI, SPIRV::ModuleAnalysisInfo &MAI,
401                               SPIRV::ModuleSectionType MSType, InstrTraces &IS,
402                               bool Append = true) {
403   MAI.setSkipEmission(&MI);
404   InstrSignature MISign = instrToSignature(MI, MAI);
405   auto FoundMI = IS.insert(MISign);
406   if (!FoundMI.second)
407     return; // insert failed, so we found a duplicate; don't add it to MAI.MS
408   // No duplicates, so add it.
409   if (Append)
410     MAI.MS[MSType].push_back(&MI);
411   else
412     MAI.MS[MSType].insert(MAI.MS[MSType].begin(), &MI);
413 }
414 
415 // Some global instructions make reference to function-local ID regs, so cannot
416 // be correctly collected until these registers are globally numbered.
417 void SPIRVModuleAnalysis::processOtherInstrs(const Module &M) {
418   InstrTraces IS;
419   for (auto F = M.begin(), E = M.end(); F != E; ++F) {
420     if ((*F).isDeclaration())
421       continue;
422     MachineFunction *MF = MMI->getMachineFunction(*F);
423     assert(MF);
424     for (MachineBasicBlock &MBB : *MF)
425       for (MachineInstr &MI : MBB) {
426         if (MAI.getSkipEmission(&MI))
427           continue;
428         const unsigned OpCode = MI.getOpcode();
429         if (OpCode == SPIRV::OpString) {
430           collectOtherInstr(MI, MAI, SPIRV::MB_DebugStrings, IS);
431         } else if (OpCode == SPIRV::OpExtInst && MI.getOperand(2).isImm() &&
432                    MI.getOperand(2).getImm() ==
433                        SPIRV::InstructionSet::
434                            NonSemantic_Shader_DebugInfo_100) {
435           MachineOperand Ins = MI.getOperand(3);
436           namespace NS = SPIRV::NonSemanticExtInst;
437           static constexpr int64_t GlobalNonSemanticDITy[] = {
438               NS::DebugSource, NS::DebugCompilationUnit, NS::DebugInfoNone,
439               NS::DebugTypeBasic};
440           bool IsGlobalDI = false;
441           for (unsigned Idx = 0; Idx < std::size(GlobalNonSemanticDITy); ++Idx)
442             IsGlobalDI |= Ins.getImm() == GlobalNonSemanticDITy[Idx];
443           if (IsGlobalDI)
444             collectOtherInstr(MI, MAI, SPIRV::MB_NonSemanticGlobalDI, IS);
445         } else if (OpCode == SPIRV::OpName || OpCode == SPIRV::OpMemberName) {
446           collectOtherInstr(MI, MAI, SPIRV::MB_DebugNames, IS);
447         } else if (OpCode == SPIRV::OpEntryPoint) {
448           collectOtherInstr(MI, MAI, SPIRV::MB_EntryPoints, IS);
449         } else if (TII->isDecorationInstr(MI)) {
450           collectOtherInstr(MI, MAI, SPIRV::MB_Annotations, IS);
451           collectFuncNames(MI, &*F);
452         } else if (TII->isConstantInstr(MI)) {
453           // Now OpSpecConstant*s are not in DT,
454           // but they need to be collected anyway.
455           collectOtherInstr(MI, MAI, SPIRV::MB_TypeConstVars, IS);
456         } else if (OpCode == SPIRV::OpFunction) {
457           collectFuncNames(MI, &*F);
458         } else if (OpCode == SPIRV::OpTypeForwardPointer) {
459           collectOtherInstr(MI, MAI, SPIRV::MB_TypeConstVars, IS, false);
460         }
461       }
462   }
463 }
464 
465 // Number registers in all functions globally from 0 onwards and store
466 // the result in global register alias table. Some registers are already
467 // numbered in collectGlobalEntities.
468 void SPIRVModuleAnalysis::numberRegistersGlobally(const Module &M) {
469   for (auto F = M.begin(), E = M.end(); F != E; ++F) {
470     if ((*F).isDeclaration())
471       continue;
472     MachineFunction *MF = MMI->getMachineFunction(*F);
473     assert(MF);
474     for (MachineBasicBlock &MBB : *MF) {
475       for (MachineInstr &MI : MBB) {
476         for (MachineOperand &Op : MI.operands()) {
477           if (!Op.isReg())
478             continue;
479           Register Reg = Op.getReg();
480           if (MAI.hasRegisterAlias(MF, Reg))
481             continue;
482           Register NewReg = Register::index2VirtReg(MAI.getNextID());
483           MAI.setRegisterAlias(MF, Reg, NewReg);
484         }
485         if (MI.getOpcode() != SPIRV::OpExtInst)
486           continue;
487         auto Set = MI.getOperand(2).getImm();
488         if (!MAI.ExtInstSetMap.contains(Set))
489           MAI.ExtInstSetMap[Set] = Register::index2VirtReg(MAI.getNextID());
490       }
491     }
492   }
493 }
494 
495 // RequirementHandler implementations.
496 void SPIRV::RequirementHandler::getAndAddRequirements(
497     SPIRV::OperandCategory::OperandCategory Category, uint32_t i,
498     const SPIRVSubtarget &ST) {
499   addRequirements(getSymbolicOperandRequirements(Category, i, ST, *this));
500 }
501 
502 void SPIRV::RequirementHandler::recursiveAddCapabilities(
503     const CapabilityList &ToPrune) {
504   for (const auto &Cap : ToPrune) {
505     AllCaps.insert(Cap);
506     CapabilityList ImplicitDecls =
507         getSymbolicOperandCapabilities(OperandCategory::CapabilityOperand, Cap);
508     recursiveAddCapabilities(ImplicitDecls);
509   }
510 }
511 
512 void SPIRV::RequirementHandler::addCapabilities(const CapabilityList &ToAdd) {
513   for (const auto &Cap : ToAdd) {
514     bool IsNewlyInserted = AllCaps.insert(Cap).second;
515     if (!IsNewlyInserted) // Don't re-add if it's already been declared.
516       continue;
517     CapabilityList ImplicitDecls =
518         getSymbolicOperandCapabilities(OperandCategory::CapabilityOperand, Cap);
519     recursiveAddCapabilities(ImplicitDecls);
520     MinimalCaps.push_back(Cap);
521   }
522 }
523 
524 void SPIRV::RequirementHandler::addRequirements(
525     const SPIRV::Requirements &Req) {
526   if (!Req.IsSatisfiable)
527     report_fatal_error("Adding SPIR-V requirements this target can't satisfy.");
528 
529   if (Req.Cap.has_value())
530     addCapabilities({Req.Cap.value()});
531 
532   addExtensions(Req.Exts);
533 
534   if (!Req.MinVer.empty()) {
535     if (!MaxVersion.empty() && Req.MinVer > MaxVersion) {
536       LLVM_DEBUG(dbgs() << "Conflicting version requirements: >= " << Req.MinVer
537                         << " and <= " << MaxVersion << "\n");
538       report_fatal_error("Adding SPIR-V requirements that can't be satisfied.");
539     }
540 
541     if (MinVersion.empty() || Req.MinVer > MinVersion)
542       MinVersion = Req.MinVer;
543   }
544 
545   if (!Req.MaxVer.empty()) {
546     if (!MinVersion.empty() && Req.MaxVer < MinVersion) {
547       LLVM_DEBUG(dbgs() << "Conflicting version requirements: <= " << Req.MaxVer
548                         << " and >= " << MinVersion << "\n");
549       report_fatal_error("Adding SPIR-V requirements that can't be satisfied.");
550     }
551 
552     if (MaxVersion.empty() || Req.MaxVer < MaxVersion)
553       MaxVersion = Req.MaxVer;
554   }
555 }
556 
557 void SPIRV::RequirementHandler::checkSatisfiable(
558     const SPIRVSubtarget &ST) const {
559   // Report as many errors as possible before aborting the compilation.
560   bool IsSatisfiable = true;
561   auto TargetVer = ST.getSPIRVVersion();
562 
563   if (!MaxVersion.empty() && !TargetVer.empty() && MaxVersion < TargetVer) {
564     LLVM_DEBUG(
565         dbgs() << "Target SPIR-V version too high for required features\n"
566                << "Required max version: " << MaxVersion << " target version "
567                << TargetVer << "\n");
568     IsSatisfiable = false;
569   }
570 
571   if (!MinVersion.empty() && !TargetVer.empty() && MinVersion > TargetVer) {
572     LLVM_DEBUG(dbgs() << "Target SPIR-V version too low for required features\n"
573                       << "Required min version: " << MinVersion
574                       << " target version " << TargetVer << "\n");
575     IsSatisfiable = false;
576   }
577 
578   if (!MinVersion.empty() && !MaxVersion.empty() && MinVersion > MaxVersion) {
579     LLVM_DEBUG(
580         dbgs()
581         << "Version is too low for some features and too high for others.\n"
582         << "Required SPIR-V min version: " << MinVersion
583         << " required SPIR-V max version " << MaxVersion << "\n");
584     IsSatisfiable = false;
585   }
586 
587   for (auto Cap : MinimalCaps) {
588     if (AvailableCaps.contains(Cap))
589       continue;
590     LLVM_DEBUG(dbgs() << "Capability not supported: "
591                       << getSymbolicOperandMnemonic(
592                              OperandCategory::CapabilityOperand, Cap)
593                       << "\n");
594     IsSatisfiable = false;
595   }
596 
597   for (auto Ext : AllExtensions) {
598     if (ST.canUseExtension(Ext))
599       continue;
600     LLVM_DEBUG(dbgs() << "Extension not supported: "
601                       << getSymbolicOperandMnemonic(
602                              OperandCategory::ExtensionOperand, Ext)
603                       << "\n");
604     IsSatisfiable = false;
605   }
606 
607   if (!IsSatisfiable)
608     report_fatal_error("Unable to meet SPIR-V requirements for this target.");
609 }
610 
611 // Add the given capabilities and all their implicitly defined capabilities too.
612 void SPIRV::RequirementHandler::addAvailableCaps(const CapabilityList &ToAdd) {
613   for (const auto Cap : ToAdd)
614     if (AvailableCaps.insert(Cap).second)
615       addAvailableCaps(getSymbolicOperandCapabilities(
616           SPIRV::OperandCategory::CapabilityOperand, Cap));
617 }
618 
619 void SPIRV::RequirementHandler::removeCapabilityIf(
620     const Capability::Capability ToRemove,
621     const Capability::Capability IfPresent) {
622   if (AllCaps.contains(IfPresent))
623     AllCaps.erase(ToRemove);
624 }
625 
626 namespace llvm {
627 namespace SPIRV {
628 void RequirementHandler::initAvailableCapabilities(const SPIRVSubtarget &ST) {
629   if (ST.isOpenCLEnv()) {
630     initAvailableCapabilitiesForOpenCL(ST);
631     return;
632   }
633 
634   if (ST.isVulkanEnv()) {
635     initAvailableCapabilitiesForVulkan(ST);
636     return;
637   }
638 
639   report_fatal_error("Unimplemented environment for SPIR-V generation.");
640 }
641 
642 void RequirementHandler::initAvailableCapabilitiesForOpenCL(
643     const SPIRVSubtarget &ST) {
644   // Add the min requirements for different OpenCL and SPIR-V versions.
645   addAvailableCaps({Capability::Addresses, Capability::Float16Buffer,
646                     Capability::Int16, Capability::Int8, Capability::Kernel,
647                     Capability::Linkage, Capability::Vector16,
648                     Capability::Groups, Capability::GenericPointer,
649                     Capability::Shader});
650   if (ST.hasOpenCLFullProfile())
651     addAvailableCaps({Capability::Int64, Capability::Int64Atomics});
652   if (ST.hasOpenCLImageSupport()) {
653     addAvailableCaps({Capability::ImageBasic, Capability::LiteralSampler,
654                       Capability::Image1D, Capability::SampledBuffer,
655                       Capability::ImageBuffer});
656     if (ST.isAtLeastOpenCLVer(VersionTuple(2, 0)))
657       addAvailableCaps({Capability::ImageReadWrite});
658   }
659   if (ST.isAtLeastSPIRVVer(VersionTuple(1, 1)) &&
660       ST.isAtLeastOpenCLVer(VersionTuple(2, 2)))
661     addAvailableCaps({Capability::SubgroupDispatch, Capability::PipeStorage});
662   if (ST.isAtLeastSPIRVVer(VersionTuple(1, 3)))
663     addAvailableCaps({Capability::GroupNonUniform,
664                       Capability::GroupNonUniformVote,
665                       Capability::GroupNonUniformArithmetic,
666                       Capability::GroupNonUniformBallot,
667                       Capability::GroupNonUniformClustered,
668                       Capability::GroupNonUniformShuffle,
669                       Capability::GroupNonUniformShuffleRelative});
670   if (ST.isAtLeastSPIRVVer(VersionTuple(1, 4)))
671     addAvailableCaps({Capability::DenormPreserve, Capability::DenormFlushToZero,
672                       Capability::SignedZeroInfNanPreserve,
673                       Capability::RoundingModeRTE,
674                       Capability::RoundingModeRTZ});
675   // TODO: verify if this needs some checks.
676   addAvailableCaps({Capability::Float16, Capability::Float64});
677 
678   // Add capabilities enabled by extensions.
679   for (auto Extension : ST.getAllAvailableExtensions()) {
680     CapabilityList EnabledCapabilities =
681         getCapabilitiesEnabledByExtension(Extension);
682     addAvailableCaps(EnabledCapabilities);
683   }
684 
685   // TODO: add OpenCL extensions.
686 }
687 
688 void RequirementHandler::initAvailableCapabilitiesForVulkan(
689     const SPIRVSubtarget &ST) {
690   addAvailableCaps({Capability::Shader, Capability::Linkage});
691 
692   // Provided by all supported Vulkan versions.
693   addAvailableCaps({Capability::Int16, Capability::Int64, Capability::Float16,
694                     Capability::Float64, Capability::GroupNonUniform});
695 }
696 
697 } // namespace SPIRV
698 } // namespace llvm
699 
700 // Add the required capabilities from a decoration instruction (including
701 // BuiltIns).
702 static void addOpDecorateReqs(const MachineInstr &MI, unsigned DecIndex,
703                               SPIRV::RequirementHandler &Reqs,
704                               const SPIRVSubtarget &ST) {
705   int64_t DecOp = MI.getOperand(DecIndex).getImm();
706   auto Dec = static_cast<SPIRV::Decoration::Decoration>(DecOp);
707   Reqs.addRequirements(getSymbolicOperandRequirements(
708       SPIRV::OperandCategory::DecorationOperand, Dec, ST, Reqs));
709 
710   if (Dec == SPIRV::Decoration::BuiltIn) {
711     int64_t BuiltInOp = MI.getOperand(DecIndex + 1).getImm();
712     auto BuiltIn = static_cast<SPIRV::BuiltIn::BuiltIn>(BuiltInOp);
713     Reqs.addRequirements(getSymbolicOperandRequirements(
714         SPIRV::OperandCategory::BuiltInOperand, BuiltIn, ST, Reqs));
715   } else if (Dec == SPIRV::Decoration::LinkageAttributes) {
716     int64_t LinkageOp = MI.getOperand(MI.getNumOperands() - 1).getImm();
717     SPIRV::LinkageType::LinkageType LnkType =
718         static_cast<SPIRV::LinkageType::LinkageType>(LinkageOp);
719     if (LnkType == SPIRV::LinkageType::LinkOnceODR)
720       Reqs.addExtension(SPIRV::Extension::SPV_KHR_linkonce_odr);
721   } else if (Dec == SPIRV::Decoration::CacheControlLoadINTEL ||
722              Dec == SPIRV::Decoration::CacheControlStoreINTEL) {
723     Reqs.addExtension(SPIRV::Extension::SPV_INTEL_cache_controls);
724   } else if (Dec == SPIRV::Decoration::HostAccessINTEL) {
725     Reqs.addExtension(SPIRV::Extension::SPV_INTEL_global_variable_host_access);
726   } else if (Dec == SPIRV::Decoration::InitModeINTEL ||
727              Dec == SPIRV::Decoration::ImplementInRegisterMapINTEL) {
728     Reqs.addExtension(
729         SPIRV::Extension::SPV_INTEL_global_variable_fpga_decorations);
730   }
731 }
732 
733 // Add requirements for image handling.
734 static void addOpTypeImageReqs(const MachineInstr &MI,
735                                SPIRV::RequirementHandler &Reqs,
736                                const SPIRVSubtarget &ST) {
737   assert(MI.getNumOperands() >= 8 && "Insufficient operands for OpTypeImage");
738   // The operand indices used here are based on the OpTypeImage layout, which
739   // the MachineInstr follows as well.
740   int64_t ImgFormatOp = MI.getOperand(7).getImm();
741   auto ImgFormat = static_cast<SPIRV::ImageFormat::ImageFormat>(ImgFormatOp);
742   Reqs.getAndAddRequirements(SPIRV::OperandCategory::ImageFormatOperand,
743                              ImgFormat, ST);
744 
745   bool IsArrayed = MI.getOperand(4).getImm() == 1;
746   bool IsMultisampled = MI.getOperand(5).getImm() == 1;
747   bool NoSampler = MI.getOperand(6).getImm() == 2;
748   // Add dimension requirements.
749   assert(MI.getOperand(2).isImm());
750   switch (MI.getOperand(2).getImm()) {
751   case SPIRV::Dim::DIM_1D:
752     Reqs.addRequirements(NoSampler ? SPIRV::Capability::Image1D
753                                    : SPIRV::Capability::Sampled1D);
754     break;
755   case SPIRV::Dim::DIM_2D:
756     if (IsMultisampled && NoSampler)
757       Reqs.addRequirements(SPIRV::Capability::ImageMSArray);
758     break;
759   case SPIRV::Dim::DIM_Cube:
760     Reqs.addRequirements(SPIRV::Capability::Shader);
761     if (IsArrayed)
762       Reqs.addRequirements(NoSampler ? SPIRV::Capability::ImageCubeArray
763                                      : SPIRV::Capability::SampledCubeArray);
764     break;
765   case SPIRV::Dim::DIM_Rect:
766     Reqs.addRequirements(NoSampler ? SPIRV::Capability::ImageRect
767                                    : SPIRV::Capability::SampledRect);
768     break;
769   case SPIRV::Dim::DIM_Buffer:
770     Reqs.addRequirements(NoSampler ? SPIRV::Capability::ImageBuffer
771                                    : SPIRV::Capability::SampledBuffer);
772     break;
773   case SPIRV::Dim::DIM_SubpassData:
774     Reqs.addRequirements(SPIRV::Capability::InputAttachment);
775     break;
776   }
777 
778   // Has optional access qualifier.
779   // TODO: check if it's OpenCL's kernel.
780   if (MI.getNumOperands() > 8 &&
781       MI.getOperand(8).getImm() == SPIRV::AccessQualifier::ReadWrite)
782     Reqs.addRequirements(SPIRV::Capability::ImageReadWrite);
783   else
784     Reqs.addRequirements(SPIRV::Capability::ImageBasic);
785 }
786 
787 // Add requirements for handling atomic float instructions
788 #define ATOM_FLT_REQ_EXT_MSG(ExtName)                                          \
789   "The atomic float instruction requires the following SPIR-V "                \
790   "extension: SPV_EXT_shader_atomic_float" ExtName
791 static void AddAtomicFloatRequirements(const MachineInstr &MI,
792                                        SPIRV::RequirementHandler &Reqs,
793                                        const SPIRVSubtarget &ST) {
794   assert(MI.getOperand(1).isReg() &&
795          "Expect register operand in atomic float instruction");
796   Register TypeReg = MI.getOperand(1).getReg();
797   SPIRVType *TypeDef = MI.getMF()->getRegInfo().getVRegDef(TypeReg);
798   if (TypeDef->getOpcode() != SPIRV::OpTypeFloat)
799     report_fatal_error("Result type of an atomic float instruction must be a "
800                        "floating-point type scalar");
801 
802   unsigned BitWidth = TypeDef->getOperand(1).getImm();
803   unsigned Op = MI.getOpcode();
804   if (Op == SPIRV::OpAtomicFAddEXT) {
805     if (!ST.canUseExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_add))
806       report_fatal_error(ATOM_FLT_REQ_EXT_MSG("_add"), false);
807     Reqs.addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_add);
808     switch (BitWidth) {
809     case 16:
810       if (!ST.canUseExtension(
811               SPIRV::Extension::SPV_EXT_shader_atomic_float16_add))
812         report_fatal_error(ATOM_FLT_REQ_EXT_MSG("16_add"), false);
813       Reqs.addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float16_add);
814       Reqs.addCapability(SPIRV::Capability::AtomicFloat16AddEXT);
815       break;
816     case 32:
817       Reqs.addCapability(SPIRV::Capability::AtomicFloat32AddEXT);
818       break;
819     case 64:
820       Reqs.addCapability(SPIRV::Capability::AtomicFloat64AddEXT);
821       break;
822     default:
823       report_fatal_error(
824           "Unexpected floating-point type width in atomic float instruction");
825     }
826   } else {
827     if (!ST.canUseExtension(
828             SPIRV::Extension::SPV_EXT_shader_atomic_float_min_max))
829       report_fatal_error(ATOM_FLT_REQ_EXT_MSG("_min_max"), false);
830     Reqs.addExtension(SPIRV::Extension::SPV_EXT_shader_atomic_float_min_max);
831     switch (BitWidth) {
832     case 16:
833       Reqs.addCapability(SPIRV::Capability::AtomicFloat16MinMaxEXT);
834       break;
835     case 32:
836       Reqs.addCapability(SPIRV::Capability::AtomicFloat32MinMaxEXT);
837       break;
838     case 64:
839       Reqs.addCapability(SPIRV::Capability::AtomicFloat64MinMaxEXT);
840       break;
841     default:
842       report_fatal_error(
843           "Unexpected floating-point type width in atomic float instruction");
844     }
845   }
846 }
847 
848 void addInstrRequirements(const MachineInstr &MI,
849                           SPIRV::RequirementHandler &Reqs,
850                           const SPIRVSubtarget &ST) {
851   switch (MI.getOpcode()) {
852   case SPIRV::OpMemoryModel: {
853     int64_t Addr = MI.getOperand(0).getImm();
854     Reqs.getAndAddRequirements(SPIRV::OperandCategory::AddressingModelOperand,
855                                Addr, ST);
856     int64_t Mem = MI.getOperand(1).getImm();
857     Reqs.getAndAddRequirements(SPIRV::OperandCategory::MemoryModelOperand, Mem,
858                                ST);
859     break;
860   }
861   case SPIRV::OpEntryPoint: {
862     int64_t Exe = MI.getOperand(0).getImm();
863     Reqs.getAndAddRequirements(SPIRV::OperandCategory::ExecutionModelOperand,
864                                Exe, ST);
865     break;
866   }
867   case SPIRV::OpExecutionMode:
868   case SPIRV::OpExecutionModeId: {
869     int64_t Exe = MI.getOperand(1).getImm();
870     Reqs.getAndAddRequirements(SPIRV::OperandCategory::ExecutionModeOperand,
871                                Exe, ST);
872     break;
873   }
874   case SPIRV::OpTypeMatrix:
875     Reqs.addCapability(SPIRV::Capability::Matrix);
876     break;
877   case SPIRV::OpTypeInt: {
878     unsigned BitWidth = MI.getOperand(1).getImm();
879     if (BitWidth == 64)
880       Reqs.addCapability(SPIRV::Capability::Int64);
881     else if (BitWidth == 16)
882       Reqs.addCapability(SPIRV::Capability::Int16);
883     else if (BitWidth == 8)
884       Reqs.addCapability(SPIRV::Capability::Int8);
885     break;
886   }
887   case SPIRV::OpTypeFloat: {
888     unsigned BitWidth = MI.getOperand(1).getImm();
889     if (BitWidth == 64)
890       Reqs.addCapability(SPIRV::Capability::Float64);
891     else if (BitWidth == 16)
892       Reqs.addCapability(SPIRV::Capability::Float16);
893     break;
894   }
895   case SPIRV::OpTypeVector: {
896     unsigned NumComponents = MI.getOperand(2).getImm();
897     if (NumComponents == 8 || NumComponents == 16)
898       Reqs.addCapability(SPIRV::Capability::Vector16);
899     break;
900   }
901   case SPIRV::OpTypePointer: {
902     auto SC = MI.getOperand(1).getImm();
903     Reqs.getAndAddRequirements(SPIRV::OperandCategory::StorageClassOperand, SC,
904                                ST);
905     // If it's a type of pointer to float16 targeting OpenCL, add Float16Buffer
906     // capability.
907     if (!ST.isOpenCLEnv())
908       break;
909     assert(MI.getOperand(2).isReg());
910     const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo();
911     SPIRVType *TypeDef = MRI.getVRegDef(MI.getOperand(2).getReg());
912     if (TypeDef->getOpcode() == SPIRV::OpTypeFloat &&
913         TypeDef->getOperand(1).getImm() == 16)
914       Reqs.addCapability(SPIRV::Capability::Float16Buffer);
915     break;
916   }
917   case SPIRV::OpExtInst: {
918     if (MI.getOperand(2).getImm() ==
919         static_cast<int64_t>(
920             SPIRV::InstructionSet::NonSemantic_Shader_DebugInfo_100)) {
921       Reqs.addExtension(SPIRV::Extension::SPV_KHR_non_semantic_info);
922     }
923     break;
924   }
925   case SPIRV::OpBitReverse:
926   case SPIRV::OpBitFieldInsert:
927   case SPIRV::OpBitFieldSExtract:
928   case SPIRV::OpBitFieldUExtract:
929     if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_bit_instructions)) {
930       Reqs.addCapability(SPIRV::Capability::Shader);
931       break;
932     }
933     Reqs.addExtension(SPIRV::Extension::SPV_KHR_bit_instructions);
934     Reqs.addCapability(SPIRV::Capability::BitInstructions);
935     break;
936   case SPIRV::OpTypeRuntimeArray:
937     Reqs.addCapability(SPIRV::Capability::Shader);
938     break;
939   case SPIRV::OpTypeOpaque:
940   case SPIRV::OpTypeEvent:
941     Reqs.addCapability(SPIRV::Capability::Kernel);
942     break;
943   case SPIRV::OpTypePipe:
944   case SPIRV::OpTypeReserveId:
945     Reqs.addCapability(SPIRV::Capability::Pipes);
946     break;
947   case SPIRV::OpTypeDeviceEvent:
948   case SPIRV::OpTypeQueue:
949   case SPIRV::OpBuildNDRange:
950     Reqs.addCapability(SPIRV::Capability::DeviceEnqueue);
951     break;
952   case SPIRV::OpDecorate:
953   case SPIRV::OpDecorateId:
954   case SPIRV::OpDecorateString:
955     addOpDecorateReqs(MI, 1, Reqs, ST);
956     break;
957   case SPIRV::OpMemberDecorate:
958   case SPIRV::OpMemberDecorateString:
959     addOpDecorateReqs(MI, 2, Reqs, ST);
960     break;
961   case SPIRV::OpInBoundsPtrAccessChain:
962     Reqs.addCapability(SPIRV::Capability::Addresses);
963     break;
964   case SPIRV::OpConstantSampler:
965     Reqs.addCapability(SPIRV::Capability::LiteralSampler);
966     break;
967   case SPIRV::OpTypeImage:
968     addOpTypeImageReqs(MI, Reqs, ST);
969     break;
970   case SPIRV::OpTypeSampler:
971     Reqs.addCapability(SPIRV::Capability::ImageBasic);
972     break;
973   case SPIRV::OpTypeForwardPointer:
974     // TODO: check if it's OpenCL's kernel.
975     Reqs.addCapability(SPIRV::Capability::Addresses);
976     break;
977   case SPIRV::OpAtomicFlagTestAndSet:
978   case SPIRV::OpAtomicLoad:
979   case SPIRV::OpAtomicStore:
980   case SPIRV::OpAtomicExchange:
981   case SPIRV::OpAtomicCompareExchange:
982   case SPIRV::OpAtomicIIncrement:
983   case SPIRV::OpAtomicIDecrement:
984   case SPIRV::OpAtomicIAdd:
985   case SPIRV::OpAtomicISub:
986   case SPIRV::OpAtomicUMin:
987   case SPIRV::OpAtomicUMax:
988   case SPIRV::OpAtomicSMin:
989   case SPIRV::OpAtomicSMax:
990   case SPIRV::OpAtomicAnd:
991   case SPIRV::OpAtomicOr:
992   case SPIRV::OpAtomicXor: {
993     const MachineRegisterInfo &MRI = MI.getMF()->getRegInfo();
994     const MachineInstr *InstrPtr = &MI;
995     if (MI.getOpcode() == SPIRV::OpAtomicStore) {
996       assert(MI.getOperand(3).isReg());
997       InstrPtr = MRI.getVRegDef(MI.getOperand(3).getReg());
998       assert(InstrPtr && "Unexpected type instruction for OpAtomicStore");
999     }
1000     assert(InstrPtr->getOperand(1).isReg() && "Unexpected operand in atomic");
1001     Register TypeReg = InstrPtr->getOperand(1).getReg();
1002     SPIRVType *TypeDef = MRI.getVRegDef(TypeReg);
1003     if (TypeDef->getOpcode() == SPIRV::OpTypeInt) {
1004       unsigned BitWidth = TypeDef->getOperand(1).getImm();
1005       if (BitWidth == 64)
1006         Reqs.addCapability(SPIRV::Capability::Int64Atomics);
1007     }
1008     break;
1009   }
1010   case SPIRV::OpGroupNonUniformIAdd:
1011   case SPIRV::OpGroupNonUniformFAdd:
1012   case SPIRV::OpGroupNonUniformIMul:
1013   case SPIRV::OpGroupNonUniformFMul:
1014   case SPIRV::OpGroupNonUniformSMin:
1015   case SPIRV::OpGroupNonUniformUMin:
1016   case SPIRV::OpGroupNonUniformFMin:
1017   case SPIRV::OpGroupNonUniformSMax:
1018   case SPIRV::OpGroupNonUniformUMax:
1019   case SPIRV::OpGroupNonUniformFMax:
1020   case SPIRV::OpGroupNonUniformBitwiseAnd:
1021   case SPIRV::OpGroupNonUniformBitwiseOr:
1022   case SPIRV::OpGroupNonUniformBitwiseXor:
1023   case SPIRV::OpGroupNonUniformLogicalAnd:
1024   case SPIRV::OpGroupNonUniformLogicalOr:
1025   case SPIRV::OpGroupNonUniformLogicalXor: {
1026     assert(MI.getOperand(3).isImm());
1027     int64_t GroupOp = MI.getOperand(3).getImm();
1028     switch (GroupOp) {
1029     case SPIRV::GroupOperation::Reduce:
1030     case SPIRV::GroupOperation::InclusiveScan:
1031     case SPIRV::GroupOperation::ExclusiveScan:
1032       Reqs.addCapability(SPIRV::Capability::Kernel);
1033       Reqs.addCapability(SPIRV::Capability::GroupNonUniformArithmetic);
1034       Reqs.addCapability(SPIRV::Capability::GroupNonUniformBallot);
1035       break;
1036     case SPIRV::GroupOperation::ClusteredReduce:
1037       Reqs.addCapability(SPIRV::Capability::GroupNonUniformClustered);
1038       break;
1039     case SPIRV::GroupOperation::PartitionedReduceNV:
1040     case SPIRV::GroupOperation::PartitionedInclusiveScanNV:
1041     case SPIRV::GroupOperation::PartitionedExclusiveScanNV:
1042       Reqs.addCapability(SPIRV::Capability::GroupNonUniformPartitionedNV);
1043       break;
1044     }
1045     break;
1046   }
1047   case SPIRV::OpGroupNonUniformShuffle:
1048   case SPIRV::OpGroupNonUniformShuffleXor:
1049     Reqs.addCapability(SPIRV::Capability::GroupNonUniformShuffle);
1050     break;
1051   case SPIRV::OpGroupNonUniformShuffleUp:
1052   case SPIRV::OpGroupNonUniformShuffleDown:
1053     Reqs.addCapability(SPIRV::Capability::GroupNonUniformShuffleRelative);
1054     break;
1055   case SPIRV::OpGroupAll:
1056   case SPIRV::OpGroupAny:
1057   case SPIRV::OpGroupBroadcast:
1058   case SPIRV::OpGroupIAdd:
1059   case SPIRV::OpGroupFAdd:
1060   case SPIRV::OpGroupFMin:
1061   case SPIRV::OpGroupUMin:
1062   case SPIRV::OpGroupSMin:
1063   case SPIRV::OpGroupFMax:
1064   case SPIRV::OpGroupUMax:
1065   case SPIRV::OpGroupSMax:
1066     Reqs.addCapability(SPIRV::Capability::Groups);
1067     break;
1068   case SPIRV::OpGroupNonUniformElect:
1069     Reqs.addCapability(SPIRV::Capability::GroupNonUniform);
1070     break;
1071   case SPIRV::OpGroupNonUniformAll:
1072   case SPIRV::OpGroupNonUniformAny:
1073   case SPIRV::OpGroupNonUniformAllEqual:
1074     Reqs.addCapability(SPIRV::Capability::GroupNonUniformVote);
1075     break;
1076   case SPIRV::OpGroupNonUniformBroadcast:
1077   case SPIRV::OpGroupNonUniformBroadcastFirst:
1078   case SPIRV::OpGroupNonUniformBallot:
1079   case SPIRV::OpGroupNonUniformInverseBallot:
1080   case SPIRV::OpGroupNonUniformBallotBitExtract:
1081   case SPIRV::OpGroupNonUniformBallotBitCount:
1082   case SPIRV::OpGroupNonUniformBallotFindLSB:
1083   case SPIRV::OpGroupNonUniformBallotFindMSB:
1084     Reqs.addCapability(SPIRV::Capability::GroupNonUniformBallot);
1085     break;
1086   case SPIRV::OpSubgroupShuffleINTEL:
1087   case SPIRV::OpSubgroupShuffleDownINTEL:
1088   case SPIRV::OpSubgroupShuffleUpINTEL:
1089   case SPIRV::OpSubgroupShuffleXorINTEL:
1090     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
1091       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
1092       Reqs.addCapability(SPIRV::Capability::SubgroupShuffleINTEL);
1093     }
1094     break;
1095   case SPIRV::OpSubgroupBlockReadINTEL:
1096   case SPIRV::OpSubgroupBlockWriteINTEL:
1097     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
1098       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
1099       Reqs.addCapability(SPIRV::Capability::SubgroupBufferBlockIOINTEL);
1100     }
1101     break;
1102   case SPIRV::OpSubgroupImageBlockReadINTEL:
1103   case SPIRV::OpSubgroupImageBlockWriteINTEL:
1104     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_subgroups)) {
1105       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_subgroups);
1106       Reqs.addCapability(SPIRV::Capability::SubgroupImageBlockIOINTEL);
1107     }
1108     break;
1109   case SPIRV::OpAssumeTrueKHR:
1110   case SPIRV::OpExpectKHR:
1111     if (ST.canUseExtension(SPIRV::Extension::SPV_KHR_expect_assume)) {
1112       Reqs.addExtension(SPIRV::Extension::SPV_KHR_expect_assume);
1113       Reqs.addCapability(SPIRV::Capability::ExpectAssumeKHR);
1114     }
1115     break;
1116   case SPIRV::OpPtrCastToCrossWorkgroupINTEL:
1117   case SPIRV::OpCrossWorkgroupCastToPtrINTEL:
1118     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_usm_storage_classes)) {
1119       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_usm_storage_classes);
1120       Reqs.addCapability(SPIRV::Capability::USMStorageClassesINTEL);
1121     }
1122     break;
1123   case SPIRV::OpConstantFunctionPointerINTEL:
1124     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_function_pointers)) {
1125       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_function_pointers);
1126       Reqs.addCapability(SPIRV::Capability::FunctionPointersINTEL);
1127     }
1128     break;
1129   case SPIRV::OpGroupNonUniformRotateKHR:
1130     if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_subgroup_rotate))
1131       report_fatal_error("OpGroupNonUniformRotateKHR instruction requires the "
1132                          "following SPIR-V extension: SPV_KHR_subgroup_rotate",
1133                          false);
1134     Reqs.addExtension(SPIRV::Extension::SPV_KHR_subgroup_rotate);
1135     Reqs.addCapability(SPIRV::Capability::GroupNonUniformRotateKHR);
1136     Reqs.addCapability(SPIRV::Capability::GroupNonUniform);
1137     break;
1138   case SPIRV::OpGroupIMulKHR:
1139   case SPIRV::OpGroupFMulKHR:
1140   case SPIRV::OpGroupBitwiseAndKHR:
1141   case SPIRV::OpGroupBitwiseOrKHR:
1142   case SPIRV::OpGroupBitwiseXorKHR:
1143   case SPIRV::OpGroupLogicalAndKHR:
1144   case SPIRV::OpGroupLogicalOrKHR:
1145   case SPIRV::OpGroupLogicalXorKHR:
1146     if (ST.canUseExtension(
1147             SPIRV::Extension::SPV_KHR_uniform_group_instructions)) {
1148       Reqs.addExtension(SPIRV::Extension::SPV_KHR_uniform_group_instructions);
1149       Reqs.addCapability(SPIRV::Capability::GroupUniformArithmeticKHR);
1150     }
1151     break;
1152   case SPIRV::OpReadClockKHR:
1153     if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_shader_clock))
1154       report_fatal_error("OpReadClockKHR instruction requires the "
1155                          "following SPIR-V extension: SPV_KHR_shader_clock",
1156                          false);
1157     Reqs.addExtension(SPIRV::Extension::SPV_KHR_shader_clock);
1158     Reqs.addCapability(SPIRV::Capability::ShaderClockKHR);
1159     break;
1160   case SPIRV::OpFunctionPointerCallINTEL:
1161     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_function_pointers)) {
1162       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_function_pointers);
1163       Reqs.addCapability(SPIRV::Capability::FunctionPointersINTEL);
1164     }
1165     break;
1166   case SPIRV::OpAtomicFAddEXT:
1167   case SPIRV::OpAtomicFMinEXT:
1168   case SPIRV::OpAtomicFMaxEXT:
1169     AddAtomicFloatRequirements(MI, Reqs, ST);
1170     break;
1171   case SPIRV::OpConvertBF16ToFINTEL:
1172   case SPIRV::OpConvertFToBF16INTEL:
1173     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_bfloat16_conversion)) {
1174       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_bfloat16_conversion);
1175       Reqs.addCapability(SPIRV::Capability::BFloat16ConversionINTEL);
1176     }
1177     break;
1178   case SPIRV::OpVariableLengthArrayINTEL:
1179   case SPIRV::OpSaveMemoryINTEL:
1180   case SPIRV::OpRestoreMemoryINTEL:
1181     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_variable_length_array)) {
1182       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_variable_length_array);
1183       Reqs.addCapability(SPIRV::Capability::VariableLengthArrayINTEL);
1184     }
1185     break;
1186   case SPIRV::OpAsmTargetINTEL:
1187   case SPIRV::OpAsmINTEL:
1188   case SPIRV::OpAsmCallINTEL:
1189     if (ST.canUseExtension(SPIRV::Extension::SPV_INTEL_inline_assembly)) {
1190       Reqs.addExtension(SPIRV::Extension::SPV_INTEL_inline_assembly);
1191       Reqs.addCapability(SPIRV::Capability::AsmINTEL);
1192     }
1193     break;
1194   case SPIRV::OpTypeCooperativeMatrixKHR:
1195     if (!ST.canUseExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix))
1196       report_fatal_error(
1197           "OpTypeCooperativeMatrixKHR type requires the "
1198           "following SPIR-V extension: SPV_KHR_cooperative_matrix",
1199           false);
1200     Reqs.addExtension(SPIRV::Extension::SPV_KHR_cooperative_matrix);
1201     Reqs.addCapability(SPIRV::Capability::CooperativeMatrixKHR);
1202     break;
1203   default:
1204     break;
1205   }
1206 
1207   // If we require capability Shader, then we can remove the requirement for
1208   // the BitInstructions capability, since Shader is a superset capability
1209   // of BitInstructions.
1210   Reqs.removeCapabilityIf(SPIRV::Capability::BitInstructions,
1211                           SPIRV::Capability::Shader);
1212 }
1213 
1214 static void collectReqs(const Module &M, SPIRV::ModuleAnalysisInfo &MAI,
1215                         MachineModuleInfo *MMI, const SPIRVSubtarget &ST) {
1216   // Collect requirements for existing instructions.
1217   for (auto F = M.begin(), E = M.end(); F != E; ++F) {
1218     MachineFunction *MF = MMI->getMachineFunction(*F);
1219     if (!MF)
1220       continue;
1221     for (const MachineBasicBlock &MBB : *MF)
1222       for (const MachineInstr &MI : MBB)
1223         addInstrRequirements(MI, MAI.Reqs, ST);
1224   }
1225   // Collect requirements for OpExecutionMode instructions.
1226   auto Node = M.getNamedMetadata("spirv.ExecutionMode");
1227   if (Node) {
1228     // SPV_KHR_float_controls is not available until v1.4
1229     bool RequireFloatControls = false,
1230          VerLower14 = !ST.isAtLeastSPIRVVer(VersionTuple(1, 4));
1231     for (unsigned i = 0; i < Node->getNumOperands(); i++) {
1232       MDNode *MDN = cast<MDNode>(Node->getOperand(i));
1233       const MDOperand &MDOp = MDN->getOperand(1);
1234       if (auto *CMeta = dyn_cast<ConstantAsMetadata>(MDOp)) {
1235         Constant *C = CMeta->getValue();
1236         if (ConstantInt *Const = dyn_cast<ConstantInt>(C)) {
1237           auto EM = Const->getZExtValue();
1238           MAI.Reqs.getAndAddRequirements(
1239               SPIRV::OperandCategory::ExecutionModeOperand, EM, ST);
1240           // add SPV_KHR_float_controls if the version is too low
1241           switch (EM) {
1242           case SPIRV::ExecutionMode::DenormPreserve:
1243           case SPIRV::ExecutionMode::DenormFlushToZero:
1244           case SPIRV::ExecutionMode::SignedZeroInfNanPreserve:
1245           case SPIRV::ExecutionMode::RoundingModeRTE:
1246           case SPIRV::ExecutionMode::RoundingModeRTZ:
1247             RequireFloatControls = VerLower14;
1248             break;
1249           }
1250         }
1251       }
1252     }
1253     if (RequireFloatControls &&
1254         ST.canUseExtension(SPIRV::Extension::SPV_KHR_float_controls))
1255       MAI.Reqs.addExtension(SPIRV::Extension::SPV_KHR_float_controls);
1256   }
1257   for (auto FI = M.begin(), E = M.end(); FI != E; ++FI) {
1258     const Function &F = *FI;
1259     if (F.isDeclaration())
1260       continue;
1261     if (F.getMetadata("reqd_work_group_size"))
1262       MAI.Reqs.getAndAddRequirements(
1263           SPIRV::OperandCategory::ExecutionModeOperand,
1264           SPIRV::ExecutionMode::LocalSize, ST);
1265     if (F.getFnAttribute("hlsl.numthreads").isValid()) {
1266       MAI.Reqs.getAndAddRequirements(
1267           SPIRV::OperandCategory::ExecutionModeOperand,
1268           SPIRV::ExecutionMode::LocalSize, ST);
1269     }
1270     if (F.getMetadata("work_group_size_hint"))
1271       MAI.Reqs.getAndAddRequirements(
1272           SPIRV::OperandCategory::ExecutionModeOperand,
1273           SPIRV::ExecutionMode::LocalSizeHint, ST);
1274     if (F.getMetadata("intel_reqd_sub_group_size"))
1275       MAI.Reqs.getAndAddRequirements(
1276           SPIRV::OperandCategory::ExecutionModeOperand,
1277           SPIRV::ExecutionMode::SubgroupSize, ST);
1278     if (F.getMetadata("vec_type_hint"))
1279       MAI.Reqs.getAndAddRequirements(
1280           SPIRV::OperandCategory::ExecutionModeOperand,
1281           SPIRV::ExecutionMode::VecTypeHint, ST);
1282 
1283     if (F.hasOptNone() &&
1284         ST.canUseExtension(SPIRV::Extension::SPV_INTEL_optnone)) {
1285       // Output OpCapability OptNoneINTEL.
1286       MAI.Reqs.addExtension(SPIRV::Extension::SPV_INTEL_optnone);
1287       MAI.Reqs.addCapability(SPIRV::Capability::OptNoneINTEL);
1288     }
1289   }
1290 }
1291 
1292 static unsigned getFastMathFlags(const MachineInstr &I) {
1293   unsigned Flags = SPIRV::FPFastMathMode::None;
1294   if (I.getFlag(MachineInstr::MIFlag::FmNoNans))
1295     Flags |= SPIRV::FPFastMathMode::NotNaN;
1296   if (I.getFlag(MachineInstr::MIFlag::FmNoInfs))
1297     Flags |= SPIRV::FPFastMathMode::NotInf;
1298   if (I.getFlag(MachineInstr::MIFlag::FmNsz))
1299     Flags |= SPIRV::FPFastMathMode::NSZ;
1300   if (I.getFlag(MachineInstr::MIFlag::FmArcp))
1301     Flags |= SPIRV::FPFastMathMode::AllowRecip;
1302   if (I.getFlag(MachineInstr::MIFlag::FmReassoc))
1303     Flags |= SPIRV::FPFastMathMode::Fast;
1304   return Flags;
1305 }
1306 
1307 static void handleMIFlagDecoration(MachineInstr &I, const SPIRVSubtarget &ST,
1308                                    const SPIRVInstrInfo &TII,
1309                                    SPIRV::RequirementHandler &Reqs) {
1310   if (I.getFlag(MachineInstr::MIFlag::NoSWrap) && TII.canUseNSW(I) &&
1311       getSymbolicOperandRequirements(SPIRV::OperandCategory::DecorationOperand,
1312                                      SPIRV::Decoration::NoSignedWrap, ST, Reqs)
1313           .IsSatisfiable) {
1314     buildOpDecorate(I.getOperand(0).getReg(), I, TII,
1315                     SPIRV::Decoration::NoSignedWrap, {});
1316   }
1317   if (I.getFlag(MachineInstr::MIFlag::NoUWrap) && TII.canUseNUW(I) &&
1318       getSymbolicOperandRequirements(SPIRV::OperandCategory::DecorationOperand,
1319                                      SPIRV::Decoration::NoUnsignedWrap, ST,
1320                                      Reqs)
1321           .IsSatisfiable) {
1322     buildOpDecorate(I.getOperand(0).getReg(), I, TII,
1323                     SPIRV::Decoration::NoUnsignedWrap, {});
1324   }
1325   if (!TII.canUseFastMathFlags(I))
1326     return;
1327   unsigned FMFlags = getFastMathFlags(I);
1328   if (FMFlags == SPIRV::FPFastMathMode::None)
1329     return;
1330   Register DstReg = I.getOperand(0).getReg();
1331   buildOpDecorate(DstReg, I, TII, SPIRV::Decoration::FPFastMathMode, {FMFlags});
1332 }
1333 
1334 // Walk all functions and add decorations related to MI flags.
1335 static void addDecorations(const Module &M, const SPIRVInstrInfo &TII,
1336                            MachineModuleInfo *MMI, const SPIRVSubtarget &ST,
1337                            SPIRV::ModuleAnalysisInfo &MAI) {
1338   for (auto F = M.begin(), E = M.end(); F != E; ++F) {
1339     MachineFunction *MF = MMI->getMachineFunction(*F);
1340     if (!MF)
1341       continue;
1342     for (auto &MBB : *MF)
1343       for (auto &MI : MBB)
1344         handleMIFlagDecoration(MI, ST, TII, MAI.Reqs);
1345   }
1346 }
1347 
1348 struct SPIRV::ModuleAnalysisInfo SPIRVModuleAnalysis::MAI;
1349 
1350 void SPIRVModuleAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
1351   AU.addRequired<TargetPassConfig>();
1352   AU.addRequired<MachineModuleInfoWrapperPass>();
1353 }
1354 
1355 bool SPIRVModuleAnalysis::runOnModule(Module &M) {
1356   SPIRVTargetMachine &TM =
1357       getAnalysis<TargetPassConfig>().getTM<SPIRVTargetMachine>();
1358   ST = TM.getSubtargetImpl();
1359   GR = ST->getSPIRVGlobalRegistry();
1360   TII = ST->getInstrInfo();
1361 
1362   MMI = &getAnalysis<MachineModuleInfoWrapperPass>().getMMI();
1363 
1364   setBaseInfo(M);
1365 
1366   addDecorations(M, *TII, MMI, *ST, MAI);
1367 
1368   collectReqs(M, MAI, MMI, *ST);
1369 
1370   // Process type/const/global var/func decl instructions, number their
1371   // destination registers from 0 to N, collect Extensions and Capabilities.
1372   processDefInstrs(M);
1373 
1374   // Number rest of registers from N+1 onwards.
1375   numberRegistersGlobally(M);
1376 
1377   // Update references to OpFunction instructions to use Global Registers
1378   if (GR->hasConstFunPtr())
1379     collectFuncPtrs();
1380 
1381   // Collect OpName, OpEntryPoint, OpDecorate etc, process other instructions.
1382   processOtherInstrs(M);
1383 
1384   // If there are no entry points, we need the Linkage capability.
1385   if (MAI.MS[SPIRV::MB_EntryPoints].empty())
1386     MAI.Reqs.addCapability(SPIRV::Capability::Linkage);
1387 
1388   // Set maximum ID used.
1389   GR->setBound(MAI.MaxID);
1390 
1391   return false;
1392 }
1393