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 namespace CooperativeMatrixLayout { 211 #define GET_CooperativeMatrixLayout_DECL 212 #include "SPIRVGenTables.inc" 213 } // namespace CooperativeMatrixLayout 214 215 namespace CooperativeMatrixOperands { 216 #define GET_CooperativeMatrixOperands_DECL 217 #include "SPIRVGenTables.inc" 218 } // namespace CooperativeMatrixOperands 219 220 struct ExtendedBuiltin { 221 StringRef Name; 222 InstructionSet::InstructionSet Set; 223 uint32_t Number; 224 }; 225 } // namespace SPIRV 226 227 using CapabilityList = SmallVector<SPIRV::Capability::Capability, 8>; 228 using ExtensionList = SmallVector<SPIRV::Extension::Extension, 8>; 229 230 std::string 231 getSymbolicOperandMnemonic(SPIRV::OperandCategory::OperandCategory Category, 232 int32_t Value); 233 VersionTuple 234 getSymbolicOperandMinVersion(SPIRV::OperandCategory::OperandCategory Category, 235 uint32_t Value); 236 VersionTuple 237 getSymbolicOperandMaxVersion(SPIRV::OperandCategory::OperandCategory Category, 238 uint32_t Value); 239 CapabilityList 240 getSymbolicOperandCapabilities(SPIRV::OperandCategory::OperandCategory Category, 241 uint32_t Value); 242 CapabilityList 243 getCapabilitiesEnabledByExtension(SPIRV::Extension::Extension Extension); 244 ExtensionList 245 getSymbolicOperandExtensions(SPIRV::OperandCategory::OperandCategory Category, 246 uint32_t Value); 247 std::string getLinkStringForBuiltIn(SPIRV::BuiltIn::BuiltIn BuiltInValue); 248 249 bool getSpirvBuiltInIdByName(StringRef Name, SPIRV::BuiltIn::BuiltIn &BI); 250 251 std::string getExtInstSetName(SPIRV::InstructionSet::InstructionSet Set); 252 SPIRV::InstructionSet::InstructionSet 253 getExtInstSetFromString(std::string SetName); 254 std::string getExtInstName(SPIRV::InstructionSet::InstructionSet Set, 255 uint32_t InstructionNumber); 256 257 // Return a string representation of the operands from startIndex onwards. 258 // Templated to allow both MachineInstr and MCInst to use the same logic. 259 template <class InstType> 260 std::string getSPIRVStringOperand(const InstType &MI, unsigned StartIndex) { 261 std::string s; // Iteratively append to this string. 262 263 const unsigned NumOps = MI.getNumOperands(); 264 bool IsFinished = false; 265 for (unsigned i = StartIndex; i < NumOps && !IsFinished; ++i) { 266 const auto &Op = MI.getOperand(i); 267 if (!Op.isImm()) // Stop if we hit a register operand. 268 break; 269 assert((Op.getImm() >> 32) == 0 && "Imm operand should be i32 word"); 270 const uint32_t Imm = Op.getImm(); // Each i32 word is up to 4 characters. 271 for (unsigned ShiftAmount = 0; ShiftAmount < 32; ShiftAmount += 8) { 272 char c = (Imm >> ShiftAmount) & 0xff; 273 if (c == 0) { // Stop if we hit a null-terminator character. 274 IsFinished = true; 275 break; 276 } 277 s += c; // Otherwise, append the character to the result string. 278 } 279 } 280 return s; 281 } 282 } // namespace llvm 283 #endif // LLVM_LIB_TARGET_SPIRV_SPIRVSYMBOLICOPERANDS_H 284