1 //===-- SPIRVBaseInfo.h - Top level SPIRV definitions -----------*- 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 // This file contains TableGen generated enum definitions, mnemonic lookup
10 // functions, versioning/capabilities/extensions getters for symbolic/named
11 // operands for various SPIR-V instructions.
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
16 #define LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
17
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/Support/VersionTuple.h"
21 #include <string>
22
23 namespace llvm {
24 namespace SPIRV {
25 namespace OperandCategory {
26 #define GET_OperandCategory_DECL
27 #include "SPIRVGenTables.inc"
28 } // namespace OperandCategory
29
30 namespace Extension {
31 #define GET_Extension_DECL
32 #include "SPIRVGenTables.inc"
33 } // namespace Extension
34
35 namespace Capability {
36 #define GET_Capability_DECL
37 #include "SPIRVGenTables.inc"
38 } // namespace Capability
39
40 namespace SourceLanguage {
41 #define GET_SourceLanguage_DECL
42 #include "SPIRVGenTables.inc"
43 } // namespace SourceLanguage
44
45 namespace AddressingModel {
46 #define GET_AddressingModel_DECL
47 #include "SPIRVGenTables.inc"
48 } // namespace AddressingModel
49
50 namespace ExecutionModel {
51 #define GET_ExecutionModel_DECL
52 #include "SPIRVGenTables.inc"
53 } // namespace ExecutionModel
54
55 namespace MemoryModel {
56 #define GET_MemoryModel_DECL
57 #include "SPIRVGenTables.inc"
58 } // namespace MemoryModel
59
60 namespace ExecutionMode {
61 #define GET_ExecutionMode_DECL
62 #include "SPIRVGenTables.inc"
63 } // namespace ExecutionMode
64
65 namespace StorageClass {
66 #define GET_StorageClass_DECL
67 #include "SPIRVGenTables.inc"
68 } // namespace StorageClass
69
70 namespace Dim {
71 #define GET_Dim_DECL
72 #include "SPIRVGenTables.inc"
73 } // namespace Dim
74
75 namespace SamplerAddressingMode {
76 #define GET_SamplerAddressingMode_DECL
77 #include "SPIRVGenTables.inc"
78 } // namespace SamplerAddressingMode
79
80 namespace SamplerFilterMode {
81 #define GET_SamplerFilterMode_DECL
82 #include "SPIRVGenTables.inc"
83 } // namespace SamplerFilterMode
84
85 namespace ImageFormat {
86 #define GET_ImageFormat_DECL
87 #include "SPIRVGenTables.inc"
88 } // namespace ImageFormat
89
90 namespace ImageChannelOrder {
91 #define GET_ImageChannelOrder_DECL
92 #include "SPIRVGenTables.inc"
93 } // namespace ImageChannelOrder
94
95 namespace ImageChannelDataType {
96 #define GET_ImageChannelDataType_DECL
97 #include "SPIRVGenTables.inc"
98 } // namespace ImageChannelDataType
99
100 namespace ImageOperand {
101 #define GET_ImageOperand_DECL
102 #include "SPIRVGenTables.inc"
103 } // namespace ImageOperand
104
105 namespace FPFastMathMode {
106 #define GET_FPFastMathMode_DECL
107 #include "SPIRVGenTables.inc"
108 } // namespace FPFastMathMode
109
110 namespace FPRoundingMode {
111 #define GET_FPRoundingMode_DECL
112 #include "SPIRVGenTables.inc"
113 } // namespace FPRoundingMode
114
115 namespace LinkageType {
116 #define GET_LinkageType_DECL
117 #include "SPIRVGenTables.inc"
118 } // namespace LinkageType
119
120 namespace AccessQualifier {
121 #define GET_AccessQualifier_DECL
122 #include "SPIRVGenTables.inc"
123 } // namespace AccessQualifier
124
125 namespace FunctionParameterAttribute {
126 #define GET_FunctionParameterAttribute_DECL
127 #include "SPIRVGenTables.inc"
128 } // namespace FunctionParameterAttribute
129
130 namespace Decoration {
131 #define GET_Decoration_DECL
132 #include "SPIRVGenTables.inc"
133 } // namespace Decoration
134
135 namespace BuiltIn {
136 #define GET_BuiltIn_DECL
137 #include "SPIRVGenTables.inc"
138 } // namespace BuiltIn
139
140 namespace SelectionControl {
141 #define GET_SelectionControl_DECL
142 #include "SPIRVGenTables.inc"
143 } // namespace SelectionControl
144
145 namespace LoopControl {
146 #define GET_LoopControl_DECL
147 #include "SPIRVGenTables.inc"
148 } // namespace LoopControl
149
150 namespace FunctionControl {
151 #define GET_FunctionControl_DECL
152 #include "SPIRVGenTables.inc"
153 } // namespace FunctionControl
154
155 namespace MemorySemantics {
156 #define GET_MemorySemantics_DECL
157 #include "SPIRVGenTables.inc"
158 } // namespace MemorySemantics
159
160 namespace MemoryOperand {
161 #define GET_MemoryOperand_DECL
162 #include "SPIRVGenTables.inc"
163 } // namespace MemoryOperand
164
165 namespace Scope {
166 #define GET_Scope_DECL
167 #include "SPIRVGenTables.inc"
168 } // namespace Scope
169
170 namespace GroupOperation {
171 #define GET_GroupOperation_DECL
172 #include "SPIRVGenTables.inc"
173 } // namespace GroupOperation
174
175 namespace KernelEnqueueFlags {
176 #define GET_KernelEnqueueFlags_DECL
177 #include "SPIRVGenTables.inc"
178 } // namespace KernelEnqueueFlags
179
180 namespace KernelProfilingInfo {
181 #define GET_KernelProfilingInfo_DECL
182 #include "SPIRVGenTables.inc"
183 } // namespace KernelProfilingInfo
184
185 namespace InstructionSet {
186 #define GET_InstructionSet_DECL
187 #include "SPIRVGenTables.inc"
188 } // namespace InstructionSet
189
190 namespace OpenCLExtInst {
191 #define GET_OpenCLExtInst_DECL
192 #include "SPIRVGenTables.inc"
193 } // namespace OpenCLExtInst
194
195 namespace GLSLExtInst {
196 #define GET_GLSLExtInst_DECL
197 #include "SPIRVGenTables.inc"
198 } // namespace GLSLExtInst
199
200 namespace NonSemanticExtInst {
201 #define GET_NonSemanticExtInst_DECL
202 #include "SPIRVGenTables.inc"
203 } // namespace NonSemanticExtInst
204
205 namespace Opcode {
206 #define GET_Opcode_DECL
207 #include "SPIRVGenTables.inc"
208 } // namespace Opcode
209
210 struct ExtendedBuiltin {
211 StringRef Name;
212 InstructionSet::InstructionSet Set;
213 uint32_t Number;
214 };
215 } // namespace SPIRV
216
217 using CapabilityList = SmallVector<SPIRV::Capability::Capability, 8>;
218 using ExtensionList = SmallVector<SPIRV::Extension::Extension, 8>;
219
220 std::string
221 getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category,
222 int32_t Value);
223 VersionTuple
224 getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category,
225 uint32_t Value);
226 VersionTuple
227 getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category,
228 uint32_t Value);
229 CapabilityList
230 getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category,
231 uint32_t Value);
232 CapabilityList
233 getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension);
234 ExtensionList
235 getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category,
236 uint32_t Value);
237 std::string getLinkStringForBuiltIn(SPIRV::BuiltIn::BuiltIn BuiltInValue);
238
239 bool getSpirvBuiltInIdByName(StringRef Name, SPIRV::BuiltIn::BuiltIn &BI);
240
241 std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set);
242 SPIRV::InstructionSet::InstructionSet
243 getExtInstSetFromString(std::string SetName);
244 std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set,
245 uint32_t InstructionNumber);
246
247 // Return a string representation of the operands from startIndex onwards.
248 // Templated to allow both MachineInstr and MCInst to use the same logic.
249 template <class InstType>
getSPIRVStringOperand(const InstType & MI,unsigned StartIndex)250 std::string getSPIRVStringOperand(const InstType &MI, unsigned StartIndex) {
251 std::string s; // Iteratively append to this string.
252
253 const unsigned NumOps = MI.getNumOperands();
254 bool IsFinished = false;
255 for (unsigned i = StartIndex; i < NumOps && !IsFinished; ++i) {
256 const auto &Op = MI.getOperand(i);
257 if (!Op.isImm()) // Stop if we hit a register operand.
258 break;
259 assert((Op.getImm() >> 32) == 0 && "Imm operand should be i32 word");
260 const uint32_t Imm = Op.getImm(); // Each i32 word is up to 4 characters.
261 for (unsigned ShiftAmount = 0; ShiftAmount < 32; ShiftAmount += 8) {
262 char c = (Imm >> ShiftAmount) & 0xff;
263 if (c == 0) { // Stop if we hit a null-terminator character.
264 IsFinished = true;
265 break;
266 }
267 s += c; // Otherwise, append the character to the result string.
268 }
269 }
270 return s;
271 }
272 } // namespace llvm
273 #endif // LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H
274