llvm/lib/Target/SPIRV/SPIRVSymbolicOperands.td

   1 //===- SPIRVSymbolicOperands.td ----------------------------*- tablegen -*-===//
   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 defines symbolic/named operands for various SPIR-V instructions.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 include "llvm/TableGen/SearchableTable.td"
  14
  15 //===----------------------------------------------------------------------===//
  16 // Lookup table containing symbolic operands with the following columns:
  17 // - Category (Extension/Capability/BuiltIn/etc.)
  18 // - Value (32-bit representation for binary emission)
  19 // - Mnemonic (String representation for textual emission)
  20 // - MinVersion
  21 // - MaxVersion
  22 //===----------------------------------------------------------------------===//
  23
  24 // Forward-declare classes used in SymbolicOperand
  25 class OperandCategory;
  26
  27 class SymbolicOperand<OperandCategory category, bits<32> value, string mnemonic, bits<32> minVersion, bits<32> maxVersion> {
  28   OperandCategory Category = category;
  29   bits<32> Value = value;
  30   string Mnemonic = mnemonic;
  31   bits<32> MinVersion = minVersion;
  32   bits<32> MaxVersion = maxVersion;
  33 }
  34
  35 def SymbolicOperands : GenericTable {
  36   let FilterClass = "SymbolicOperand";
  37   let Fields = ["Category", "Value", "Mnemonic", "MinVersion", "MaxVersion"];
  38   string TypeOf_Category = "OperandCategory";
  39   let PrimaryKey = ["Category", "Value"];
  40   // Function for looking up symbolic operands based on category and value.
  41   let PrimaryKeyName = "lookupSymbolicOperandByCategoryAndValue";
  42 }
  43
  44 // Function for looking up symbolic operands based on just category.
  45 def lookupSymbolicOperandByCategory : SearchIndex {
  46   let Table = SymbolicOperands;
  47   let Key = ["Category"];
  48 }
  49
  50 // Function for looking up symbolic operands based on category and mnemonic.
  51 def lookupSymbolicOperandByCategoryAndMnemonic : SearchIndex {
  52   let Table = SymbolicOperands;
  53   let Key = ["Category", "Mnemonic"];
  54 }
  55
  56 //===----------------------------------------------------------------------===//
  57 // Lookup table for matching symbolic operands (category + 32-bit value) to
  58 // a SPIR-V extension.
  59 //===----------------------------------------------------------------------===//
  60
  61 // Forward-declare classes used in ExtensionEntry
  62 class Extension;
  63
  64 class ExtensionEntry<OperandCategory category, bits<32> value, Extension reqExtension> {
  65   OperandCategory Category = category;
  66   bits<32> Value = value;
  67   Extension ReqExtension = reqExtension;
  68 }
  69
  70 def ExtensionEntries : GenericTable {
  71   let FilterClass = "ExtensionEntry";
  72   let Fields = ["Category", "Value", "ReqExtension"];
  73   string TypeOf_Category = "OperandCategory";
  74   string TypeOf_ReqExtension = "Extension";
  75   let PrimaryKey = ["Category", "Value"];
  76   // Function for looking up the extension by category + value.
  77   let PrimaryKeyName = "lookupExtensionByCategoryAndValue";
  78 }
  79
  80 // Function to lookup symbolic operands enabled by a given extension.
  81 def lookupSymbolicOperandsEnabledByExtension : SearchIndex {
  82   let Table = ExtensionEntries;
  83   let Key = ["ReqExtension", "Category"];
  84 }
  85
  86 //===----------------------------------------------------------------------===//
  87 // Lookup table for matching symbolic operands (category + 32-bit value) to
  88 // SPIR-V capabilities. If an operand requires more than one capability, there
  89 // will be multiple consecutive entries present in the table.
  90 //===----------------------------------------------------------------------===//
  91
  92 // Forward-declare classes used in ExtensionEntry
  93 class Capability;
  94
  95 class CapabilityEntry<OperandCategory category, bits<32> value, Capability reqCabaility> {
  96   OperandCategory Category = category;
  97   bits<32> Value = value;
  98   Capability ReqCapability = reqCabaility;
  99 }
 100
 101 def CapabilityEntries : GenericTable {
 102   let FilterClass = "CapabilityEntry";
 103   let Fields = ["Category", "Value", "ReqCapability"];
 104   string TypeOf_Category = "OperandCategory";
 105   string TypeOf_ReqCapability = "Capability";
 106   let PrimaryKey = ["Category", "Value"];
 107   // Function for looking up a (the first) capability by category + value. Next
 108   // capabilities should be consecutive.
 109   let PrimaryKeyName = "lookupCapabilityByCategoryAndValue";
 110 }
 111
 112 //===----------------------------------------------------------------------===//
 113 // Multiclass used to define a SymbolicOperand and at the same time declare
 114 // required extension and capabilities.
 115 //===----------------------------------------------------------------------===//
 116
 117 multiclass SymbolicOperandWithRequirements<OperandCategory category, bits<32> value, string mnemonic, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
 118     assert !ge(!size(mnemonic), 1), "No mnemonic/string representation provided for symbolic operand with value " # value;
 119     def : SymbolicOperand<category, value, mnemonic, minVersion, maxVersion>;
 120
 121     assert !le(!size(reqExtensions), 1), "Too many required extensions for a symbolic/named operand: " # mnemonic;
 122     if !eq(!size(reqExtensions), 1) then {
 123         def : ExtensionEntry<category, value, reqExtensions[0]>;
 124     }
 125
 126     foreach capability = reqCapabilities in {
 127         def : CapabilityEntry<category, value, capability>;
 128     }
 129 }
 130
 131 //===----------------------------------------------------------------------===//
 132 // Enum defining different categories of symbolic/named operands.
 133 //===----------------------------------------------------------------------===//
 134
 135 def OperandCategory : GenericEnum {
 136   let FilterClass = "OperandCategory";
 137 }
 138
 139 class OperandCategory;
 140
 141 def ExtensionOperand : OperandCategory;
 142 def CapabilityOperand : OperandCategory;
 143 def SourceLanguageOperand : OperandCategory;
 144 def AddressingModelOperand : OperandCategory;
 145 def ExecutionModelOperand : OperandCategory;
 146 def MemoryModelOperand : OperandCategory;
 147 def ExecutionModeOperand : OperandCategory;
 148 def StorageClassOperand : OperandCategory;
 149 def DimOperand : OperandCategory;
 150 def SamplerAddressingModeOperand : OperandCategory;
 151 def SamplerFilterModeOperand : OperandCategory;
 152 def ImageFormatOperand : OperandCategory;
 153 def ImageChannelOrderOperand : OperandCategory;
 154 def ImageChannelDataTypeOperand : OperandCategory;
 155 def ImageOperandOperand : OperandCategory;
 156 def FPFastMathModeOperand : OperandCategory;
 157 def FPRoundingModeOperand : OperandCategory;
 158 def LinkageTypeOperand : OperandCategory;
 159 def AccessQualifierOperand : OperandCategory;
 160 def FunctionParameterAttributeOperand : OperandCategory;
 161 def DecorationOperand : OperandCategory;
 162 def BuiltInOperand : OperandCategory;
 163 def SelectionControlOperand : OperandCategory;
 164 def LoopControlOperand : OperandCategory;
 165 def FunctionControlOperand : OperandCategory;
 166 def MemorySemanticsOperand : OperandCategory;
 167 def MemoryOperandOperand : OperandCategory;
 168 def ScopeOperand : OperandCategory;
 169 def GroupOperationOperand : OperandCategory;
 170 def KernelEnqueueFlagsOperand : OperandCategory;
 171 def KernelProfilingInfoOperand : OperandCategory;
 172 def OpcodeOperand : OperandCategory;
 173
 174 //===----------------------------------------------------------------------===//
 175 // Multiclass used to define Extesions enum values and at the same time
 176 // SymbolicOperand entries.
 177 //===----------------------------------------------------------------------===//
 178
 179 def Extension : GenericEnum, Operand<i32> {
 180   let FilterClass = "Extension";
 181   let NameField = "Name";
 182   let ValueField = "Value";
 183   let PrintMethod = "printExtension";
 184 }
 185
 186 class Extension<string name, bits<32> value> {
 187   string Name = name;
 188   bits<32> Value = value;
 189 }
 190
 191 multiclass ExtensionOperand<bits<32> value> {
 192   def NAME : Extension<NAME, value>;
 193   defm : SymbolicOperandWithRequirements<ExtensionOperand, value, NAME, 0, 0, [], []>;
 194 }
 195
 196 defm SPV_AMD_shader_explicit_vertex_parameter : ExtensionOperand<1>;
 197 defm SPV_AMD_shader_trinary_minmax_extension : ExtensionOperand<2>;
 198 defm SPV_AMD_gcn_shader : ExtensionOperand<3>;
 199 defm SPV_KHR_shader_ballot : ExtensionOperand<4>;
 200 defm SPV_AMD_shader_ballot : ExtensionOperand<5>;
 201 defm SPV_AMD_gpu_shader_half_float : ExtensionOperand<6>;
 202 defm SPV_KHR_shader_draw_parameters : ExtensionOperand<7>;
 203 defm SPV_KHR_subgroup_vote : ExtensionOperand<8>;
 204 defm SPV_KHR_16bit_storage : ExtensionOperand<9>;
 205 defm SPV_KHR_device_group : ExtensionOperand<10>;
 206 defm SPV_KHR_multiview : ExtensionOperand<11>;
 207 defm SPV_NVX_multiview_per_view_attributes : ExtensionOperand<12>;
 208 defm SPV_NV_viewport_array2 : ExtensionOperand<13>;
 209 defm SPV_NV_stereo_view_rendering : ExtensionOperand<14>;
 210 defm SPV_NV_sample_mask_override_coverage : ExtensionOperand<15>;
 211 defm SPV_NV_geometry_shader_passthrough : ExtensionOperand<16>;
 212 defm SPV_AMD_texture_gather_bias_lod : ExtensionOperand<17>;
 213 defm SPV_KHR_storage_buffer_storage_class : ExtensionOperand<18>;
 214 defm SPV_KHR_variable_pointers : ExtensionOperand<19>;
 215 defm SPV_AMD_gpu_shader_int16 : ExtensionOperand<20>;
 216 defm SPV_KHR_post_depth_coverage : ExtensionOperand<21>;
 217 defm SPV_KHR_shader_atomic_counter_ops : ExtensionOperand<22>;
 218 defm SPV_EXT_shader_stencil_export : ExtensionOperand<23>;
 219 defm SPV_EXT_shader_viewport_index_layer : ExtensionOperand<24>;
 220 defm SPV_AMD_shader_image_load_store_lod : ExtensionOperand<25>;
 221 defm SPV_AMD_shader_fragment_mask : ExtensionOperand<26>;
 222 defm SPV_EXT_fragment_fully_covered : ExtensionOperand<27>;
 223 defm SPV_AMD_gpu_shader_half_float_fetch : ExtensionOperand<28>;
 224 defm SPV_GOOGLE_decorate_string : ExtensionOperand<29>;
 225 defm SPV_GOOGLE_hlsl_functionality1 : ExtensionOperand<30>;
 226 defm SPV_NV_shader_subgroup_partitioned : ExtensionOperand<31>;
 227 defm SPV_EXT_descriptor_indexing : ExtensionOperand<32>;
 228 defm SPV_KHR_8bit_storage : ExtensionOperand<33>;
 229 defm SPV_KHR_vulkan_memory_model : ExtensionOperand<34>;
 230 defm SPV_NV_ray_tracing : ExtensionOperand<35>;
 231 defm SPV_NV_compute_shader_derivatives : ExtensionOperand<36>;
 232 defm SPV_NV_fragment_shader_barycentric : ExtensionOperand<37>;
 233 defm SPV_NV_mesh_shader : ExtensionOperand<38>;
 234 defm SPV_NV_shader_image_footprint : ExtensionOperand<39>;
 235 defm SPV_NV_shading_rate : ExtensionOperand<40>;
 236 defm SPV_INTEL_subgroups : ExtensionOperand<41>;
 237 defm SPV_INTEL_media_block_io : ExtensionOperand<42>;
 238 defm SPV_EXT_fragment_invocation_density : ExtensionOperand<44>;
 239 defm SPV_KHR_no_integer_wrap_decoration : ExtensionOperand<45>;
 240 defm SPV_KHR_float_controls : ExtensionOperand<46>;
 241 defm SPV_EXT_physical_storage_buffer : ExtensionOperand<47>;
 242 defm SPV_INTEL_fpga_memory_attributes : ExtensionOperand<48>;
 243 defm SPV_NV_cooperative_matrix : ExtensionOperand<49>;
 244 defm SPV_INTEL_shader_integer_functions2 : ExtensionOperand<50>;
 245 defm SPV_INTEL_fpga_loop_controls : ExtensionOperand<51>;
 246 defm SPV_EXT_fragment_shader_interlock : ExtensionOperand<52>;
 247 defm SPV_NV_shader_sm_builtins : ExtensionOperand<53>;
 248 defm SPV_KHR_shader_clock : ExtensionOperand<54>;
 249 defm SPV_INTEL_unstructured_loop_controls : ExtensionOperand<55>;
 250 defm SPV_EXT_demote_to_helper_invocation : ExtensionOperand<56>;
 251 defm SPV_INTEL_fpga_reg : ExtensionOperand<57>;
 252 defm SPV_INTEL_blocking_pipes : ExtensionOperand<58>;
 253 defm SPV_GOOGLE_user_type : ExtensionOperand<59>;
 254 defm SPV_KHR_physical_storage_buffer : ExtensionOperand<60>;
 255 defm SPV_INTEL_kernel_attributes : ExtensionOperand<61>;
 256 defm SPV_KHR_non_semantic_info : ExtensionOperand<62>;
 257 defm SPV_INTEL_io_pipes : ExtensionOperand<63>;
 258 defm SPV_KHR_ray_tracing : ExtensionOperand<64>;
 259 defm SPV_KHR_ray_query : ExtensionOperand<65>;
 260 defm SPV_INTEL_fpga_memory_accesses : ExtensionOperand<66>;
 261 defm SPV_INTEL_arbitrary_precision_integers : ExtensionOperand<67>;
 262 defm SPV_EXT_shader_atomic_float_add : ExtensionOperand<68>;
 263 defm SPV_KHR_terminate_invocation : ExtensionOperand<69>;
 264 defm SPV_KHR_fragment_shading_rate : ExtensionOperand<70>;
 265 defm SPV_EXT_shader_image_int64 : ExtensionOperand<71>;
 266 defm SPV_INTEL_fp_fast_math_mode : ExtensionOperand<72>;
 267 defm SPV_INTEL_fpga_cluster_attributes : ExtensionOperand<73>;
 268 defm SPV_INTEL_loop_fuse : ExtensionOperand<74>;
 269 defm SPV_EXT_shader_atomic_float_min_max : ExtensionOperand<75>;
 270 defm SPV_KHR_workgroup_memory_explicit_layout : ExtensionOperand<76>;
 271 defm SPV_KHR_linkonce_odr : ExtensionOperand<77>;
 272 defm SPV_KHR_expect_assume : ExtensionOperand<78>;
 273 defm SPV_INTEL_fpga_dsp_control : ExtensionOperand<79>;
 274 defm SPV_NV_bindless_texture : ExtensionOperand<80>;
 275 defm SPV_INTEL_fpga_invocation_pipelining_attributes : ExtensionOperand<81>;
 276 defm SPV_KHR_subgroup_uniform_control_flow : ExtensionOperand<82>;
 277 defm SPV_HUAWEI_subpass_shading : ExtensionOperand<83>;
 278 defm SPV_KHR_integer_dot_product : ExtensionOperand<84>;
 279 defm SPV_EXT_shader_atomic_float16_add : ExtensionOperand<85>;
 280 defm SPV_INTEL_runtime_aligned : ExtensionOperand<86>;
 281 defm SPV_KHR_bit_instructions : ExtensionOperand<87>;
 282 defm SPV_NV_ray_tracing_motion_blur : ExtensionOperand<88>;
 283 defm SPV_KHR_uniform_group_instructions : ExtensionOperand<89>;
 284 defm SPV_KHR_subgroup_rotate : ExtensionOperand<90>;
 285 defm SPV_INTEL_split_barrier : ExtensionOperand<91>;
 286 defm SPV_KHR_ray_cull_mask : ExtensionOperand<92>;
 287 defm SPV_KHR_fragment_shader_barycentric : ExtensionOperand<93>;
 288 defm SPV_EXT_relaxed_printf_string_address_space : ExtensionOperand<94>;
 289 defm SPV_EXT_ycbcr_attachments : ExtensionOperand<95>;
 290 defm SPV_EXT_mesh_shader : ExtensionOperand<96>;
 291 defm SPV_ARM_core_builtins : ExtensionOperand<97>;
 292 defm SPV_EXT_opacity_micromap : ExtensionOperand<98>;
 293 defm SPV_NV_shader_invocation_reorder : ExtensionOperand<99>;
 294 defm SPV_INTEL_usm_storage_classes : ExtensionOperand<100>;
 295 defm SPV_INTEL_fpga_latency_control : ExtensionOperand<101>;
 296 defm SPV_INTEL_fpga_argument_interfaces : ExtensionOperand<102>;
 297 defm SPV_INTEL_optnone : ExtensionOperand<103>;
 298 defm SPV_INTEL_function_pointers : ExtensionOperand<104>;
 299 defm SPV_INTEL_variable_length_array : ExtensionOperand<105>;
 300 defm SPV_INTEL_bfloat16_conversion : ExtensionOperand<106>;
 301
 302 //===----------------------------------------------------------------------===//
 303 // Multiclass used to define Capabilities enum values and at the same time
 304 // SymbolicOperand entries with string mnemonics, versioning, extensions, and
 305 // capabilities.
 306 //===----------------------------------------------------------------------===//
 307
 308 def Capability : GenericEnum, Operand<i32> {
 309   let FilterClass = "Capability";
 310   let NameField = "Name";
 311   let ValueField = "Value";
 312   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 313 }
 314
 315 class Capability<string name, bits<32> value> {
 316   string Name = name;
 317   bits<32> Value = value;
 318 }
 319
 320 multiclass CapabilityOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
 321   def NAME : Capability<NAME, value>;
 322   defm : SymbolicOperandWithRequirements<CapabilityOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
 323 }
 324
 325 defm Matrix : CapabilityOperand<0, 0, 0, [], []>;
 326 defm Shader : CapabilityOperand<1, 0, 0, [], [Matrix]>;
 327 defm Geometry : CapabilityOperand<2, 0, 0, [], [Shader]>;
 328 defm Tessellation : CapabilityOperand<3, 0, 0, [], [Shader]>;
 329 defm Addresses : CapabilityOperand<4, 0, 0, [], []>;
 330 defm Linkage : CapabilityOperand<5, 0, 0, [], []>;
 331 defm Kernel : CapabilityOperand<6, 0, 0, [], []>;
 332 defm Vector16 : CapabilityOperand<7, 0, 0, [], [Kernel]>;
 333 defm Float16Buffer : CapabilityOperand<8, 0, 0, [], [Kernel]>;
 334 defm Float16 : CapabilityOperand<9, 0, 0, [], []>;
 335 defm Float64 : CapabilityOperand<10, 0, 0, [], []>;
 336 defm Int64 : CapabilityOperand<11, 0, 0, [], []>;
 337 defm Int64Atomics : CapabilityOperand<12, 0, 0, [], [Int64]>;
 338 defm ImageBasic : CapabilityOperand<13, 0, 0, [], [Kernel]>;
 339 defm ImageReadWrite : CapabilityOperand<14, 0, 0, [], [ImageBasic]>;
 340 defm ImageMipmap : CapabilityOperand<15, 0, 0, [], [ImageBasic]>;
 341 defm Pipes : CapabilityOperand<17, 0, 0, [], [Kernel]>;
 342 defm Groups : CapabilityOperand<18, 0, 0, [], []>;
 343 defm DeviceEnqueue : CapabilityOperand<19, 0, 0, [], []>;
 344 defm LiteralSampler : CapabilityOperand<20, 0, 0, [], [Kernel]>;
 345 defm AtomicStorage : CapabilityOperand<21, 0, 0, [], [Shader]>;
 346 defm Int16 : CapabilityOperand<22, 0, 0, [], []>;
 347 defm TessellationPointSize : CapabilityOperand<23, 0, 0, [], [Tessellation]>;
 348 defm GeometryPointSize : CapabilityOperand<24, 0, 0, [], [Geometry]>;
 349 defm ImageGatherExtended : CapabilityOperand<25, 0, 0, [], [Shader]>;
 350 defm StorageImageMultisample : CapabilityOperand<27, 0, 0, [], [Shader]>;
 351 defm UniformBufferArrayDynamicIndexing : CapabilityOperand<28, 0, 0, [], [Shader]>;
 352 defm SampledImageArrayDymnamicIndexing : CapabilityOperand<29, 0, 0, [], [Shader]>;
 353 defm ClipDistance : CapabilityOperand<32, 0, 0, [], [Shader]>;
 354 defm CullDistance : CapabilityOperand<33, 0, 0, [], [Shader]>;
 355 defm SampleRateShading : CapabilityOperand<35, 0, 0, [], [Shader]>;
 356 defm SampledRect : CapabilityOperand<37, 0, 0, [], [Shader]>;
 357 defm ImageRect : CapabilityOperand<36, 0, 0, [], [SampledRect]>;
 358 defm GenericPointer : CapabilityOperand<38, 0, 0, [], [Addresses]>;
 359 defm Int8 : CapabilityOperand<39, 0, 0, [], []>;
 360 defm InputAttachment : CapabilityOperand<40, 0, 0, [], [Shader]>;
 361 defm SparseResidency : CapabilityOperand<41, 0, 0, [], [Shader]>;
 362 defm MinLod : CapabilityOperand<42, 0, 0, [], [Shader]>;
 363 defm Sampled1D : CapabilityOperand<43, 0, 0, [], []>;
 364 defm Image1D : CapabilityOperand<44, 0, 0, [], [Sampled1D]>;
 365 defm SampledCubeArray : CapabilityOperand<45, 0, 0, [], [Shader]>;
 366 defm ImageCubeArray : CapabilityOperand<34, 0, 0, [], [SampledCubeArray]>;
 367 defm SampledBuffer : CapabilityOperand<46, 0, 0, [], []>;
 368 defm ImageBuffer : CapabilityOperand<47, 0, 0, [], [SampledBuffer]>;
 369 defm ImageMSArray : CapabilityOperand<48, 0, 0, [], [Shader]>;
 370 defm StorageImageExtendedFormats : CapabilityOperand<49, 0, 0, [], [Shader]>;
 371 defm ImageQuery : CapabilityOperand<50, 0, 0, [], [Shader]>;
 372 defm DerivativeControl : CapabilityOperand<51, 0, 0, [], [Shader]>;
 373 defm InterpolationFunction : CapabilityOperand<52, 0, 0, [], [Shader]>;
 374 defm TransformFeedback : CapabilityOperand<53, 0, 0, [], [Shader]>;
 375 defm GeometryStreams : CapabilityOperand<54, 0, 0, [], [Geometry]>;
 376 defm StorageImageReadWithoutFormat : CapabilityOperand<55, 0, 0, [], [Shader]>;
 377 defm StorageImageWriteWithoutFormat : CapabilityOperand<56, 0, 0, [], [Shader]>;
 378 defm MultiViewport : CapabilityOperand<57, 0, 0, [], [Geometry]>;
 379 defm SubgroupDispatch : CapabilityOperand<58, 0x10100, 0, [], [DeviceEnqueue]>;
 380 defm NamedBarrier : CapabilityOperand<59, 0x10100, 0, [], [Kernel]>;
 381 defm PipeStorage : CapabilityOperand<60, 0x10100, 0, [], [Pipes]>;
 382 defm GroupNonUniform : CapabilityOperand<61, 0x10300, 0, [], []>;
 383 defm GroupNonUniformVote : CapabilityOperand<62, 0x10300, 0, [], [GroupNonUniform]>;
 384 defm GroupNonUniformArithmetic : CapabilityOperand<63, 0x10300, 0, [], [GroupNonUniform]>;
 385 defm GroupNonUniformBallot : CapabilityOperand<64, 0x10300, 0, [], [GroupNonUniform]>;
 386 defm GroupNonUniformShuffle : CapabilityOperand<65, 0x10300, 0, [], [GroupNonUniform]>;
 387 defm GroupNonUniformShuffleRelative : CapabilityOperand<66, 0x10300, 0, [], [GroupNonUniform]>;
 388 defm GroupNonUniformClustered : CapabilityOperand<67, 0x10300, 0, [], [GroupNonUniform]>;
 389 defm GroupNonUniformQuad : CapabilityOperand<68, 0x10300, 0, [], [GroupNonUniform]>;
 390 defm SubgroupBallotKHR : CapabilityOperand<4423, 0, 0, [SPV_KHR_shader_ballot], []>;
 391 defm DrawParameters : CapabilityOperand<4427, 0x10300, 0, [SPV_KHR_shader_draw_parameters], [Shader]>;
 392 defm SubgroupVoteKHR : CapabilityOperand<4431, 0, 0, [SPV_KHR_subgroup_vote], []>;
 393 defm StorageBuffer16BitAccess : CapabilityOperand<4433, 0x10300, 0, [SPV_KHR_16bit_storage], []>;
 394 defm StorageUniform16 : CapabilityOperand<4434, 0x10300, 0, [SPV_KHR_16bit_storage], [StorageBuffer16BitAccess]>;
 395 defm StoragePushConstant16 : CapabilityOperand<4435, 0x10300, 0, [SPV_KHR_16bit_storage], []>;
 396 defm StorageInputOutput16 : CapabilityOperand<4436, 0x10300, 0, [SPV_KHR_16bit_storage], []>;
 397 defm DeviceGroup : CapabilityOperand<4437, 0x10300, 0, [SPV_KHR_device_group], []>;
 398 defm MultiView : CapabilityOperand<4439, 0x10300, 0, [SPV_KHR_multiview], [Shader]>;
 399 defm VariablePointersStorageBuffer : CapabilityOperand<4441, 0x10300, 0, [SPV_KHR_variable_pointers], [Shader]>;
 400 defm VariablePointers : CapabilityOperand<4442, 0x10300, 0, [SPV_KHR_variable_pointers], [VariablePointersStorageBuffer]>;
 401 defm AtomicStorageOps : CapabilityOperand<4445, 0, 0, [SPV_KHR_shader_atomic_counter_ops], []>;
 402 defm SampleMaskPostDepthCoverage : CapabilityOperand<4447, 0, 0, [SPV_KHR_post_depth_coverage], []>;
 403 defm StorageBuffer8BitAccess : CapabilityOperand<4448, 0, 0, [SPV_KHR_8bit_storage], []>;
 404 defm UniformAndStorageBuffer8BitAccess : CapabilityOperand<4449, 0, 0, [SPV_KHR_8bit_storage], [StorageBuffer8BitAccess]>;
 405 defm StoragePushConstant8 : CapabilityOperand<4450, 0, 0, [SPV_KHR_8bit_storage], []>;
 406 defm DenormPreserve : CapabilityOperand<4464, 0x10400, 0, [SPV_KHR_float_controls], []>;
 407 defm DenormFlushToZero : CapabilityOperand<4465, 0x10400, 0, [SPV_KHR_float_controls], []>;
 408 defm SignedZeroInfNanPreserve : CapabilityOperand<4466, 0x10400, 0, [SPV_KHR_float_controls], []>;
 409 defm RoundingModeRTE : CapabilityOperand<4467, 0x10400, 0, [SPV_KHR_float_controls], []>;
 410 defm RoundingModeRTZ : CapabilityOperand<4468, 0x10400, 0, [SPV_KHR_float_controls], []>;
 411 defm Float16ImageAMD : CapabilityOperand<5008, 0, 0, [], [Shader]>;
 412 defm ImageGatherBiasLodAMD : CapabilityOperand<5009, 0, 0, [], [Shader]>;
 413 defm FragmentMaskAMD : CapabilityOperand<5010, 0, 0, [], [Shader]>;
 414 defm StencilExportEXT : CapabilityOperand<5013, 0, 0, [], [Shader]>;
 415 defm ImageReadWriteLodAMD : CapabilityOperand<5015, 0, 0, [], [Shader]>;
 416 defm SampleMaskOverrideCoverageNV : CapabilityOperand<5249, 0, 0, [], [SampleRateShading]>;
 417 defm GeometryShaderPassthroughNV : CapabilityOperand<5251, 0, 0, [], [Geometry]>;
 418 defm ShaderViewportIndexLayerEXT : CapabilityOperand<5254, 0, 0, [], [MultiViewport]>;
 419 defm ShaderViewportMaskNV : CapabilityOperand<5255, 0, 0, [], [ShaderViewportIndexLayerEXT]>;
 420 defm ShaderStereoViewNV : CapabilityOperand<5259, 0, 0, [], [ShaderViewportMaskNV]>;
 421 defm PerViewAttributesNV : CapabilityOperand<5260, 0, 0, [], [MultiView]>;
 422 defm FragmentFullyCoveredEXT : CapabilityOperand<5265, 0, 0, [], [Shader]>;
 423 defm MeshShadingNV : CapabilityOperand<5266, 0, 0, [], [Shader]>;
 424 defm ShaderNonUniformEXT : CapabilityOperand<5301, 0, 0, [], [Shader]>;
 425 defm RuntimeDescriptorArrayEXT : CapabilityOperand<5302, 0, 0, [], [Shader]>;
 426 defm InputAttachmentArrayDynamicIndexingEXT : CapabilityOperand<5303, 0, 0, [], [InputAttachment]>;
 427 defm UniformTexelBufferArrayDynamicIndexingEXT : CapabilityOperand<5304, 0, 0, [], [SampledBuffer]>;
 428 defm StorageTexelBufferArrayDynamicIndexingEXT : CapabilityOperand<5305, 0, 0, [], [ImageBuffer]>;
 429 defm UniformBufferArrayNonUniformIndexingEXT : CapabilityOperand<5306, 0, 0, [], [ShaderNonUniformEXT]>;
 430 defm SampledImageArrayNonUniformIndexingEXT : CapabilityOperand<5307, 0, 0, [], [ShaderNonUniformEXT]>;
 431 defm StorageBufferArrayNonUniformIndexingEXT : CapabilityOperand<5308, 0, 0, [], [ShaderNonUniformEXT]>;
 432 defm StorageImageArrayNonUniformIndexingEXT : CapabilityOperand<5309, 0, 0, [], [ShaderNonUniformEXT]>;
 433 defm InputAttachmentArrayNonUniformIndexingEXT : CapabilityOperand<5310, 0, 0, [], [InputAttachment, ShaderNonUniformEXT]>;
 434 defm UniformTexelBufferArrayNonUniformIndexingEXT : CapabilityOperand<5311, 0, 0, [], [SampledBuffer, ShaderNonUniformEXT]>;
 435 defm StorageTexelBufferArrayNonUniformIndexingEXT : CapabilityOperand<5312, 0, 0, [], [ImageBuffer, ShaderNonUniformEXT]>;
 436 defm RayTracingNV : CapabilityOperand<5340, 0, 0, [], [Shader]>;
 437 defm SubgroupShuffleINTEL : CapabilityOperand<5568, 0, 0, [SPV_INTEL_subgroups], []>;
 438 defm SubgroupBufferBlockIOINTEL : CapabilityOperand<5569, 0, 0, [SPV_INTEL_subgroups], []>;
 439 defm SubgroupImageBlockIOINTEL : CapabilityOperand<5570, 0, 0, [SPV_INTEL_subgroups], []>;
 440 defm SubgroupImageMediaBlockIOINTEL : CapabilityOperand<5579, 0, 0, [], []>;
 441 defm SubgroupAvcMotionEstimationINTEL : CapabilityOperand<5696, 0, 0, [], []>;
 442 defm SubgroupAvcMotionEstimationIntraINTEL : CapabilityOperand<5697, 0, 0, [], []>;
 443 defm SubgroupAvcMotionEstimationChromaINTEL : CapabilityOperand<5698, 0, 0, [], []>;
 444 defm GroupNonUniformPartitionedNV : CapabilityOperand<5297, 0, 0, [], []>;
 445 defm VulkanMemoryModelKHR : CapabilityOperand<5345, 0, 0, [], []>;
 446 defm VulkanMemoryModelDeviceScopeKHR : CapabilityOperand<5346, 0, 0, [], []>;
 447 defm ImageFootprintNV : CapabilityOperand<5282, 0, 0, [], []>;
 448 defm FragmentBarycentricNV : CapabilityOperand<5284, 0, 0, [], []>;
 449 defm ComputeDerivativeGroupQuadsNV : CapabilityOperand<5288, 0, 0, [], []>;
 450 defm ComputeDerivativeGroupLinearNV : CapabilityOperand<5350, 0, 0, [], []>;
 451 defm FragmentDensityEXT : CapabilityOperand<5291, 0, 0, [], [Shader]>;
 452 defm PhysicalStorageBufferAddressesEXT : CapabilityOperand<5347, 0, 0, [], [Shader]>;
 453 defm CooperativeMatrixNV : CapabilityOperand<5357, 0, 0, [], [Shader]>;
 454 defm ArbitraryPrecisionIntegersINTEL : CapabilityOperand<5844, 0, 0, [SPV_INTEL_arbitrary_precision_integers], [Int8, Int16]>;
 455 defm OptNoneINTEL : CapabilityOperand<6094, 0, 0, [SPV_INTEL_optnone], []>;
 456 defm BitInstructions : CapabilityOperand<6025, 0, 0, [SPV_KHR_bit_instructions], []>;
 457 defm ExpectAssumeKHR : CapabilityOperand<5629, 0, 0, [SPV_KHR_expect_assume], []>;
 458 defm FunctionPointersINTEL : CapabilityOperand<5603, 0, 0, [SPV_INTEL_function_pointers], []>;
 459 defm IndirectReferencesINTEL : CapabilityOperand<5604, 0, 0, [SPV_INTEL_function_pointers], []>;
 460 defm GroupNonUniformRotateKHR : CapabilityOperand<6026, 0, 0, [SPV_KHR_subgroup_rotate], [GroupNonUniform]>;
 461 defm AtomicFloat32AddEXT : CapabilityOperand<6033, 0, 0, [SPV_EXT_shader_atomic_float_add], []>;
 462 defm AtomicFloat64AddEXT : CapabilityOperand<6034, 0, 0, [SPV_EXT_shader_atomic_float_add], []>;
 463 defm AtomicFloat16AddEXT : CapabilityOperand<6095, 0, 0, [SPV_EXT_shader_atomic_float16_add], []>;
 464 defm AtomicFloat16MinMaxEXT : CapabilityOperand<5616, 0, 0, [SPV_EXT_shader_atomic_float_min_max], []>;
 465 defm AtomicFloat32MinMaxEXT : CapabilityOperand<5612, 0, 0, [SPV_EXT_shader_atomic_float_min_max], []>;
 466 defm AtomicFloat64MinMaxEXT : CapabilityOperand<5613, 0, 0, [SPV_EXT_shader_atomic_float_min_max], []>;
 467 defm VariableLengthArrayINTEL : CapabilityOperand<5817, 0, 0, [SPV_INTEL_variable_length_array], []>;
 468 defm GroupUniformArithmeticKHR : CapabilityOperand<6400, 0, 0, [SPV_KHR_uniform_group_instructions], []>;
 469 defm USMStorageClassesINTEL : CapabilityOperand<5935, 0, 0, [SPV_INTEL_usm_storage_classes], [Kernel]>;
 470 defm BFloat16ConversionINTEL : CapabilityOperand<6115, 0, 0, [SPV_INTEL_bfloat16_conversion], []>;
 471
 472 //===----------------------------------------------------------------------===//
 473 // Multiclass used to define SourceLanguage enum values and at the same time
 474 // SymbolicOperand entries.
 475 //===----------------------------------------------------------------------===//
 476
 477 def SourceLanguage : GenericEnum, Operand<i32> {
 478   let FilterClass = "SourceLanguage";
 479   let NameField = "Name";
 480   let ValueField = "Value";
 481   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 482 }
 483
 484 class SourceLanguage<string name, bits<32> value> {
 485   string Name = name;
 486   bits<32> Value = value;
 487 }
 488
 489 multiclass SourceLanguageOperand<bits<32> value> {
 490   def : SourceLanguage<NAME, value>;
 491   defm : SymbolicOperandWithRequirements<SourceLanguageOperand, value, NAME, 0, 0, [], []>;
 492 }
 493
 494 defm Unknown : SourceLanguageOperand<0>;
 495 defm ESSL : SourceLanguageOperand<1>;
 496 defm GLSL : SourceLanguageOperand<2>;
 497 defm OpenCL_C : SourceLanguageOperand<3>;
 498 defm OpenCL_CPP : SourceLanguageOperand<4>;
 499 defm HLSL : SourceLanguageOperand<5>;
 500
 501 //===----------------------------------------------------------------------===//
 502 // Multiclass used to define AddressingModel enum values and at the same time
 503 // SymbolicOperand entries with string mnemonics, and capabilities.
 504 //===----------------------------------------------------------------------===//
 505
 506 def AddressingModel : GenericEnum, Operand<i32> {
 507   let FilterClass = "AddressingModel";
 508   let NameField = "Name";
 509   let ValueField = "Value";
 510   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 511 }
 512
 513 class AddressingModel<string name, bits<32> value> {
 514   string Name = name;
 515   bits<32> Value = value;
 516 }
 517
 518 multiclass AddressingModelOperand<bits<32> value, list<Capability> reqCapabilities> {
 519   def : AddressingModel<NAME, value>;
 520   defm : SymbolicOperandWithRequirements<AddressingModelOperand, value, NAME, 0, 0, [], reqCapabilities>;
 521 }
 522
 523 defm Logical : AddressingModelOperand<0, []>;
 524 defm Physical32 : AddressingModelOperand<1, [Addresses]>;
 525 defm Physical64 : AddressingModelOperand<2, [Addresses]>;
 526 defm PhysicalStorageBuffer64EXT : AddressingModelOperand<5348, [PhysicalStorageBufferAddressesEXT]>;
 527
 528 //===----------------------------------------------------------------------===//
 529 // Multiclass used to define ExecutionModel enum values and at the same time
 530 // SymbolicOperand entries with string mnemonics and capabilities.
 531 //===----------------------------------------------------------------------===//
 532
 533 def ExecutionModel : GenericEnum, Operand<i32> {
 534   let FilterClass = "ExecutionModel";
 535   let NameField = "Name";
 536   let ValueField = "Value";
 537   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 538 }
 539
 540 class ExecutionModel<string name, bits<32> value> {
 541   string Name = name;
 542   bits<32> Value = value;
 543 }
 544
 545 multiclass ExecutionModelOperand<bits<32> value, list<Capability> reqCapabilities> {
 546   def : ExecutionModel<NAME, value>;
 547   defm : SymbolicOperandWithRequirements<ExecutionModelOperand, value, NAME, 0, 0, [], reqCapabilities>;
 548 }
 549
 550 defm Vertex : ExecutionModelOperand<0, [Shader]>;
 551 defm TessellationControl: ExecutionModelOperand<1, [Tessellation]>;
 552 defm TessellationEvaluation: ExecutionModelOperand<2, [Tessellation]>;
 553 defm Geometry: ExecutionModelOperand<3, [Geometry]>;
 554 defm Fragment: ExecutionModelOperand<4, [Shader]>;
 555 defm GLCompute: ExecutionModelOperand<5, [Shader]>;
 556 defm Kernel: ExecutionModelOperand<6, [Kernel]>;
 557 defm TaskNV: ExecutionModelOperand<5267, [MeshShadingNV]>;
 558 defm MeshNV: ExecutionModelOperand<5268, [MeshShadingNV]>;
 559 defm RayGenerationNV: ExecutionModelOperand<5313, [RayTracingNV]>;
 560 defm IntersectionNV: ExecutionModelOperand<5314, [RayTracingNV]>;
 561 defm AnyHitNV: ExecutionModelOperand<5315, [RayTracingNV]>;
 562 defm ClosestHitNV: ExecutionModelOperand<5316, [RayTracingNV]>;
 563 defm MissNV: ExecutionModelOperand<5317, [RayTracingNV]>;
 564 defm CallableNV: ExecutionModelOperand<5318, [RayTracingNV]>;
 565
 566 //===----------------------------------------------------------------------===//
 567 // Multiclass used to define MemoryModel enum values and at the same time
 568 // SymbolicOperand entries with string mnemonics and capabilities.
 569 //===----------------------------------------------------------------------===//
 570
 571 def MemoryModel : GenericEnum, Operand<i32> {
 572   let FilterClass = "MemoryModel";
 573   let NameField = "Name";
 574   let ValueField = "Value";
 575   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 576 }
 577
 578 class MemoryModel<string name, bits<32> value> {
 579   string Name = name;
 580   bits<32> Value = value;
 581 }
 582
 583 multiclass MemoryModelOperand<bits<32> value, list<Capability> reqCapabilities> {
 584   def : MemoryModel<NAME, value>;
 585   defm : SymbolicOperandWithRequirements<MemoryModelOperand, value, NAME, 0, 0, [], reqCapabilities>;
 586 }
 587
 588 defm Simple : MemoryModelOperand<0, [Shader]>;
 589 defm GLSL450 : MemoryModelOperand<1, [Shader]>;
 590 defm OpenCL : MemoryModelOperand<2, [Kernel]>;
 591 defm VulkanKHR : MemoryModelOperand<3, [VulkanMemoryModelKHR]>;
 592
 593 //===----------------------------------------------------------------------===//
 594 // Multiclass used to define ExecutionMode enum values and at the same time
 595 // SymbolicOperand entries with string mnemonics and capabilities.
 596 //===----------------------------------------------------------------------===//
 597
 598 def ExecutionMode : GenericEnum, Operand<i32> {
 599   let FilterClass = "ExecutionMode";
 600   let NameField = "Name";
 601   let ValueField = "Value";
 602   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 603 }
 604
 605 class ExecutionMode<string name, bits<32> value> {
 606   string Name = name;
 607   bits<32> Value = value;
 608 }
 609
 610 multiclass ExecutionModeOperand<bits<32> value, list<Capability> reqCapabilities> {
 611   def : ExecutionMode<NAME, value>;
 612   defm : SymbolicOperandWithRequirements<ExecutionModeOperand, value, NAME, 0, 0, [], reqCapabilities>;
 613 }
 614
 615 defm Invocations : ExecutionModeOperand<0, [Geometry]>;
 616 defm SpacingEqual : ExecutionModeOperand<1, [Tessellation]>;
 617 defm SpacingFractionalEven : ExecutionModeOperand<2, [Tessellation]>;
 618 defm SpacingFractionalOdd : ExecutionModeOperand<3, [Tessellation]>;
 619 defm VertexOrderCw : ExecutionModeOperand<4, [Tessellation]>;
 620 defm VertexOrderCcw : ExecutionModeOperand<5, [Tessellation]>;
 621 defm PixelCenterInteger : ExecutionModeOperand<6, [Shader]>;
 622 defm OriginUpperLeft : ExecutionModeOperand<7, [Shader]>;
 623 defm OriginLowerLeft : ExecutionModeOperand<8, [Shader]>;
 624 defm EarlyFragmentTests : ExecutionModeOperand<9, [Shader]>;
 625 defm PointMode : ExecutionModeOperand<10, [Tessellation]>;
 626 defm Xfb : ExecutionModeOperand<11, [TransformFeedback]>;
 627 defm DepthReplacing : ExecutionModeOperand<12, [Shader]>;
 628 defm DepthGreater : ExecutionModeOperand<14, [Shader]>;
 629 defm DepthLess : ExecutionModeOperand<15, [Shader]>;
 630 defm DepthUnchanged : ExecutionModeOperand<16, [Shader]>;
 631 defm LocalSize : ExecutionModeOperand<17, []>;
 632 defm LocalSizeHint : ExecutionModeOperand<18, [Kernel]>;
 633 defm InputPoints : ExecutionModeOperand<19, [Geometry]>;
 634 defm InputLines : ExecutionModeOperand<20, [Geometry]>;
 635 defm InputLinesAdjacency : ExecutionModeOperand<21, [Geometry]>;
 636 defm Triangles : ExecutionModeOperand<22, [Geometry]>;
 637 defm InputTrianglesAdjacency : ExecutionModeOperand<23, [Geometry]>;
 638 defm Quads : ExecutionModeOperand<24, [Tessellation]>;
 639 defm Isolines : ExecutionModeOperand<25, [Tessellation]>;
 640 defm OutputVertices : ExecutionModeOperand<26, [Geometry]>;
 641 defm OutputPoints : ExecutionModeOperand<27, [Geometry]>;
 642 defm OutputLineStrip : ExecutionModeOperand<28, [Geometry]>;
 643 defm OutputTriangleStrip : ExecutionModeOperand<29, [Geometry]>;
 644 defm VecTypeHint : ExecutionModeOperand<30, [Kernel]>;
 645 defm ContractionOff : ExecutionModeOperand<31, [Kernel]>;
 646 defm Initializer : ExecutionModeOperand<33, [Kernel]>;
 647 defm Finalizer : ExecutionModeOperand<34, [Kernel]>;
 648 defm SubgroupSize : ExecutionModeOperand<35, [SubgroupDispatch]>;
 649 defm SubgroupsPerWorkgroup : ExecutionModeOperand<36, [SubgroupDispatch]>;
 650 defm SubgroupsPerWorkgroupId : ExecutionModeOperand<37, [SubgroupDispatch]>;
 651 defm LocalSizeId : ExecutionModeOperand<38, []>;
 652 defm LocalSizeHintId : ExecutionModeOperand<39, [Kernel]>;
 653 defm PostDepthCoverage : ExecutionModeOperand<4446, [SampleMaskPostDepthCoverage]>;
 654 defm DenormPreserve : ExecutionModeOperand<4459, [DenormPreserve]>;
 655 defm DenormFlushToZero : ExecutionModeOperand<4460, [DenormFlushToZero]>;
 656 defm SignedZeroInfNanPreserve : ExecutionModeOperand<4461, [SignedZeroInfNanPreserve]>;
 657 defm RoundingModeRTE : ExecutionModeOperand<4462, [RoundingModeRTE]>;
 658 defm RoundingModeRTZ : ExecutionModeOperand<4463, [RoundingModeRTZ]>;
 659 defm StencilRefReplacingEXT : ExecutionModeOperand<5027, [StencilExportEXT]>;
 660 defm OutputLinesNV : ExecutionModeOperand<5269, [MeshShadingNV]>;
 661 defm DerivativeGroupQuadsNV : ExecutionModeOperand<5289, [ComputeDerivativeGroupQuadsNV]>;
 662 defm DerivativeGroupLinearNV : ExecutionModeOperand<5290, [ComputeDerivativeGroupLinearNV]>;
 663 defm OutputTrianglesNV : ExecutionModeOperand<5298, [MeshShadingNV]>;
 664
 665 //===----------------------------------------------------------------------===//
 666 // Multiclass used to define StorageClass enum values and at the same time
 667 // SymbolicOperand entries with string mnemonics and capabilities.
 668 //===----------------------------------------------------------------------===//
 669
 670 def StorageClass : GenericEnum, Operand<i32> {
 671   let FilterClass = "StorageClass";
 672   let NameField = "Name";
 673   let ValueField = "Value";
 674   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 675 }
 676
 677 class StorageClass<string name, bits<32> value> {
 678   string Name = name;
 679   bits<32> Value = value;
 680 }
 681
 682 multiclass StorageClassOperand<bits<32> value, list<Capability> reqCapabilities> {
 683   def : StorageClass<NAME, value>;
 684   defm : SymbolicOperandWithRequirements<StorageClassOperand, value, NAME, 0, 0, [], reqCapabilities>;
 685 }
 686
 687 defm UniformConstant : StorageClassOperand<0, []>;
 688 defm Input : StorageClassOperand<1, []>;
 689 defm Uniform : StorageClassOperand<2, [Shader]>;
 690 defm Output : StorageClassOperand<3, [Shader]>;
 691 defm Workgroup : StorageClassOperand<4, []>;
 692 defm CrossWorkgroup : StorageClassOperand<5, []>;
 693 defm Private : StorageClassOperand<6, [Shader]>;
 694 defm Function : StorageClassOperand<7, []>;
 695 defm Generic : StorageClassOperand<8, [GenericPointer]>;
 696 defm PushConstant : StorageClassOperand<9, [Shader]>;
 697 defm AtomicCounter : StorageClassOperand<10, [AtomicStorage]>;
 698 defm Image : StorageClassOperand<11, []>;
 699 defm StorageBuffer : StorageClassOperand<12, [Shader]>;
 700 defm CallableDataNV : StorageClassOperand<5328, [RayTracingNV]>;
 701 defm IncomingCallableDataNV : StorageClassOperand<5329, [RayTracingNV]>;
 702 defm RayPayloadNV : StorageClassOperand<5338, [RayTracingNV]>;
 703 defm HitAttributeNV : StorageClassOperand<5339, [RayTracingNV]>;
 704 defm IncomingRayPayloadNV : StorageClassOperand<5342, [RayTracingNV]>;
 705 defm ShaderRecordBufferNV : StorageClassOperand<5343, [RayTracingNV]>;
 706 defm PhysicalStorageBufferEXT : StorageClassOperand<5349, [PhysicalStorageBufferAddressesEXT]>;
 707 defm CodeSectionINTEL : StorageClassOperand<5605, [FunctionPointersINTEL]>;
 708 defm DeviceOnlyINTEL : StorageClassOperand<5936, [USMStorageClassesINTEL]>;
 709 defm HostOnlyINTEL : StorageClassOperand<5937, [USMStorageClassesINTEL]>;
 710
 711 //===----------------------------------------------------------------------===//
 712 // Multiclass used to define Dim enum values and at the same time
 713 // SymbolicOperand entries with string mnemonics and capabilities.
 714 //===----------------------------------------------------------------------===//
 715
 716 def Dim : GenericEnum, Operand<i32> {
 717   let FilterClass = "Dim";
 718   let NameField = "Name";
 719   let ValueField = "Value";
 720   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 721 }
 722
 723 class Dim<string name, bits<32> value> {
 724   string Name = name;
 725   bits<32> Value = value;
 726 }
 727
 728 multiclass DimOperand<bits<32> value, string mnemonic, list<Capability> reqCapabilities> {
 729   def NAME : Dim<NAME, value>;
 730   defm : SymbolicOperandWithRequirements<DimOperand, value, mnemonic, 0, 0, [], reqCapabilities>;
 731 }
 732
 733 defm DIM_1D : DimOperand<0, "1D", [Sampled1D, Image1D]>;
 734 defm DIM_2D : DimOperand<1, "2D", [Shader, Kernel, ImageMSArray]>;
 735 defm DIM_3D : DimOperand<2, "3D", []>;
 736 defm DIM_Cube : DimOperand<3, "Cube", [Shader, ImageCubeArray]>;
 737 defm DIM_Rect : DimOperand<4, "Rect", [SampledRect, ImageRect]>;
 738 defm DIM_Buffer : DimOperand<5, "Buffer", [SampledBuffer, ImageBuffer]>;
 739 defm DIM_SubpassData : DimOperand<6, "SubpassData", [InputAttachment]>;
 740
 741 //===----------------------------------------------------------------------===//
 742 // Multiclass used to define SamplerAddressingMode enum values and at the same
 743 // time SymbolicOperand entries with string mnemonics and capabilities.
 744 //===----------------------------------------------------------------------===//
 745
 746 def SamplerAddressingMode : GenericEnum, Operand<i32> {
 747   let FilterClass = "SamplerAddressingMode";
 748   let NameField = "Name";
 749   let ValueField = "Value";
 750   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 751 }
 752
 753 class SamplerAddressingMode<string name, bits<32> value> {
 754   string Name = name;
 755   bits<32> Value = value;
 756 }
 757
 758 multiclass SamplerAddressingModeOperand<bits<32> value, list<Capability> reqCapabilities> {
 759   def : SamplerAddressingMode<NAME, value>;
 760   defm : SymbolicOperandWithRequirements<SamplerAddressingModeOperand, value, NAME, 0, 0, [], reqCapabilities>;
 761 }
 762
 763 defm None : SamplerAddressingModeOperand<0, [Kernel]>;
 764 defm ClampToEdge : SamplerAddressingModeOperand<1, [Kernel]>;
 765 defm Clamp : SamplerAddressingModeOperand<2, [Kernel]>;
 766 defm Repeat : SamplerAddressingModeOperand<3, [Kernel]>;
 767 defm RepeatMirrored : SamplerAddressingModeOperand<4, [Kernel]>;
 768
 769 //===----------------------------------------------------------------------===//
 770 // Multiclass used to define SamplerFilterMode enum values and at the same
 771 // time SymbolicOperand entries with string mnemonics and capabilities.
 772 //===----------------------------------------------------------------------===//
 773
 774 def SamplerFilterMode : GenericEnum, Operand<i32> {
 775   let FilterClass = "SamplerFilterMode";
 776   let NameField = "Name";
 777   let ValueField = "Value";
 778   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 779 }
 780
 781 class SamplerFilterMode<string name, bits<32> value> {
 782   string Name = name;
 783   bits<32> Value = value;
 784 }
 785
 786 multiclass SamplerFilterModeOperand<bits<32> value, list<Capability> reqCapabilities> {
 787   def : SamplerFilterMode<NAME, value>;
 788   defm : SymbolicOperandWithRequirements<SamplerFilterModeOperand, value, NAME, 0, 0, [], reqCapabilities>;
 789 }
 790
 791 defm Nearest : SamplerFilterModeOperand<0, [Kernel]>;
 792 defm Linear : SamplerFilterModeOperand<1, [Kernel]>;
 793
 794 //===----------------------------------------------------------------------===//
 795 // Multiclass used to define ImageFormat enum values and at the same time
 796 // SymbolicOperand entries with string mnemonics and capabilities.
 797 //===----------------------------------------------------------------------===//
 798
 799 def ImageFormat : GenericEnum, Operand<i32> {
 800   let FilterClass = "ImageFormat";
 801   let NameField = "Name";
 802   let ValueField = "Value";
 803   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 804 }
 805
 806 class ImageFormat<string name, bits<32> value> {
 807   string Name = name;
 808   bits<32> Value = value;
 809 }
 810
 811 multiclass ImageFormatOperand<bits<32> value, list<Capability> reqCapabilities> {
 812   def NAME : ImageFormat<NAME, value>;
 813   defm : SymbolicOperandWithRequirements<ImageFormatOperand, value, NAME, 0, 0, [], reqCapabilities>;
 814 }
 815
 816 defm Unknown : ImageFormatOperand<0, []>;
 817 defm Rgba32f : ImageFormatOperand<1, [Shader]>;
 818 defm Rgba16f : ImageFormatOperand<2, [Shader]>;
 819 defm R32f : ImageFormatOperand<3, [Shader]>;
 820 defm Rgba8 : ImageFormatOperand<4, [Shader]>;
 821 defm Rgba8Snorm : ImageFormatOperand<5, [Shader]>;
 822 defm Rg32f : ImageFormatOperand<6, [StorageImageExtendedFormats]>;
 823 defm Rg16f : ImageFormatOperand<7, [StorageImageExtendedFormats]>;
 824 defm R11fG11fB10f : ImageFormatOperand<8, [StorageImageExtendedFormats]>;
 825 defm R16f : ImageFormatOperand<9, [StorageImageExtendedFormats]>;
 826 defm Rgba16 : ImageFormatOperand<10, [StorageImageExtendedFormats]>;
 827 defm Rgb10A2 : ImageFormatOperand<11, [StorageImageExtendedFormats]>;
 828 defm Rg16 : ImageFormatOperand<12, [StorageImageExtendedFormats]>;
 829 defm Rg8 : ImageFormatOperand<13, [StorageImageExtendedFormats]>;
 830 defm R16 : ImageFormatOperand<14, [StorageImageExtendedFormats]>;
 831 defm R8 : ImageFormatOperand<15, [StorageImageExtendedFormats]>;
 832 defm Rgba16Snorm : ImageFormatOperand<16, [StorageImageExtendedFormats]>;
 833 defm Rg16Snorm : ImageFormatOperand<17, [StorageImageExtendedFormats]>;
 834 defm Rg8Snorm : ImageFormatOperand<18, [StorageImageExtendedFormats]>;
 835 defm R16Snorm : ImageFormatOperand<19, [StorageImageExtendedFormats]>;
 836 defm R8Snorm : ImageFormatOperand<20, [StorageImageExtendedFormats]>;
 837 defm Rgba32i : ImageFormatOperand<21, [Shader]>;
 838 defm Rgba16i : ImageFormatOperand<22, [Shader]>;
 839 defm Rgba8i : ImageFormatOperand<23, [Shader]>;
 840 defm R32i : ImageFormatOperand<24, [Shader]>;
 841 defm Rg32i : ImageFormatOperand<25, [StorageImageExtendedFormats]>;
 842 defm Rg16i : ImageFormatOperand<26, [StorageImageExtendedFormats]>;
 843 defm Rg8i : ImageFormatOperand<27, [StorageImageExtendedFormats]>;
 844 defm R16i : ImageFormatOperand<28, [StorageImageExtendedFormats]>;
 845 defm R8i : ImageFormatOperand<29, [StorageImageExtendedFormats]>;
 846 defm Rgba32ui : ImageFormatOperand<30, [Shader]>;
 847 defm Rgba16ui : ImageFormatOperand<31, [Shader]>;
 848 defm Rgba8ui : ImageFormatOperand<32, [Shader]>;
 849 defm R32ui : ImageFormatOperand<33, [Shader]>;
 850 defm Rgb10a2ui : ImageFormatOperand<34, [StorageImageExtendedFormats]>;
 851 defm Rg32ui : ImageFormatOperand<35, [StorageImageExtendedFormats]>;
 852 defm Rg16ui : ImageFormatOperand<36, [StorageImageExtendedFormats]>;
 853 defm Rg8ui : ImageFormatOperand<37, [StorageImageExtendedFormats]>;
 854 defm R16ui : ImageFormatOperand<38, [StorageImageExtendedFormats]>;
 855 defm R8ui : ImageFormatOperand<39, [StorageImageExtendedFormats]>;
 856
 857 //===----------------------------------------------------------------------===//
 858 // Multiclass used to define ImageChannelOrder enum values and at the same time
 859 // SymbolicOperand entries with string mnemonics and capabilities.
 860 //===----------------------------------------------------------------------===//
 861
 862 def ImageChannelOrder : GenericEnum, Operand<i32> {
 863   let FilterClass = "ImageChannelOrder";
 864   let NameField = "Name";
 865   let ValueField = "Value";
 866   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 867 }
 868
 869 class ImageChannelOrder<string name, bits<32> value> {
 870   string Name = name;
 871   bits<32> Value = value;
 872 }
 873
 874 multiclass ImageChannelOrderOperand<bits<32> value, list<Capability> reqCapabilities> {
 875   def : ImageChannelOrder<NAME, value>;
 876   defm : SymbolicOperandWithRequirements<ImageChannelOrderOperand, value, NAME, 0, 0, [], reqCapabilities>;
 877 }
 878
 879 defm R : ImageChannelOrderOperand<0, [Kernel]>;
 880 defm A : ImageChannelOrderOperand<1, [Kernel]>;
 881 defm RG : ImageChannelOrderOperand<2, [Kernel]>;
 882 defm RA : ImageChannelOrderOperand<3, [Kernel]>;
 883 defm RGB : ImageChannelOrderOperand<4, [Kernel]>;
 884 defm RGBA : ImageChannelOrderOperand<5, [Kernel]>;
 885 defm BGRA : ImageChannelOrderOperand<6, [Kernel]>;
 886 defm ARGB : ImageChannelOrderOperand<7, [Kernel]>;
 887 defm Intensity : ImageChannelOrderOperand<8, [Kernel]>;
 888 defm Luminance : ImageChannelOrderOperand<9, [Kernel]>;
 889 defm Rx : ImageChannelOrderOperand<10, [Kernel]>;
 890 defm RGx : ImageChannelOrderOperand<11, [Kernel]>;
 891 defm RGBx : ImageChannelOrderOperand<12, [Kernel]>;
 892 defm Depth : ImageChannelOrderOperand<13, [Kernel]>;
 893 defm DepthStencil : ImageChannelOrderOperand<14, [Kernel]>;
 894 defm sRGB : ImageChannelOrderOperand<15, [Kernel]>;
 895 defm sRGBx : ImageChannelOrderOperand<16, [Kernel]>;
 896 defm sRGBA : ImageChannelOrderOperand<17, [Kernel]>;
 897 defm sBGRA : ImageChannelOrderOperand<18, [Kernel]>;
 898 defm ABGR : ImageChannelOrderOperand<19, [Kernel]>;
 899
 900 //===----------------------------------------------------------------------===//
 901 // Multiclass used to define ImageChannelDataType enum values and at the same
 902 // time SymbolicOperand entries with string mnemonics and capabilities.
 903 //===----------------------------------------------------------------------===//
 904
 905 def ImageChannelDataType : GenericEnum, Operand<i32> {
 906   let FilterClass = "ImageChannelDataType";
 907   let NameField = "Name";
 908   let ValueField = "Value";
 909   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 910 }
 911
 912 class ImageChannelDataType<string name, bits<32> value> {
 913   string Name = name;
 914   bits<32> Value = value;
 915 }
 916
 917 multiclass ImageChannelDataTypeOperand<bits<32> value, list<Capability> reqCapabilities> {
 918   def : ImageChannelDataType<NAME, value>;
 919   defm : SymbolicOperandWithRequirements<ImageChannelDataTypeOperand, value, NAME, 0, 0, [], reqCapabilities>;
 920 }
 921
 922 defm SnormInt8 : ImageChannelDataTypeOperand<0, []>;
 923 defm SnormInt16 : ImageChannelDataTypeOperand<1, []>;
 924 defm UnormInt8 : ImageChannelDataTypeOperand<2, [Kernel]>;
 925 defm UnormInt16 : ImageChannelDataTypeOperand<3, [Kernel]>;
 926 defm UnormShort565 : ImageChannelDataTypeOperand<4, [Kernel]>;
 927 defm UnormShort555 : ImageChannelDataTypeOperand<5, [Kernel]>;
 928 defm UnormInt101010 : ImageChannelDataTypeOperand<6, [Kernel]>;
 929 defm SignedInt8 : ImageChannelDataTypeOperand<7, [Kernel]>;
 930 defm SignedInt16 : ImageChannelDataTypeOperand<8, [Kernel]>;
 931 defm SignedInt32 : ImageChannelDataTypeOperand<9, [Kernel]>;
 932 defm UnsignedInt8 : ImageChannelDataTypeOperand<10, [Kernel]>;
 933 defm UnsignedInt16 : ImageChannelDataTypeOperand<11, [Kernel]>;
 934 defm UnsigendInt32 : ImageChannelDataTypeOperand<12, [Kernel]>;
 935 defm HalfFloat : ImageChannelDataTypeOperand<13, [Kernel]>;
 936 defm Float : ImageChannelDataTypeOperand<14, [Kernel]>;
 937 defm UnormInt24 : ImageChannelDataTypeOperand<15, [Kernel]>;
 938 defm UnormInt101010_2 : ImageChannelDataTypeOperand<16, [Kernel]>;
 939
 940 //===----------------------------------------------------------------------===//
 941 // Multiclass used to define ImageOperand enum values and at the same time
 942 // SymbolicOperand entries with string mnemonics and capabilities.
 943 //===----------------------------------------------------------------------===//
 944
 945 def ImageOperand : GenericEnum, Operand<i32> {
 946   let FilterClass = "ImageOperand";
 947   let NameField = "Name";
 948   let ValueField = "Value";
 949   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 950 }
 951
 952 class ImageOperand<string name, bits<32> value> {
 953   string Name = name;
 954   bits<32> Value = value;
 955 }
 956
 957 multiclass ImageOperandOperand<bits<32> value, list<Capability> reqCapabilities> {
 958   def : ImageOperand<NAME, value>;
 959   defm : SymbolicOperandWithRequirements<ImageOperandOperand, value, NAME, 0, 0, [], reqCapabilities>;
 960 }
 961
 962 defm None : ImageOperandOperand<0x0, []>;
 963 defm Bias : ImageOperandOperand<0x1, [Shader]>;
 964 defm Lod : ImageOperandOperand<0x2, []>;
 965 defm Grad : ImageOperandOperand<0x4, []>;
 966 defm ConstOffset : ImageOperandOperand<0x8, []>;
 967 defm Offset : ImageOperandOperand<0x10, [ImageGatherExtended]>;
 968 defm ConstOffsets : ImageOperandOperand<0x20, [ImageGatherExtended]>;
 969 defm Sample : ImageOperandOperand<0x40, []>;
 970 defm MinLod : ImageOperandOperand<0x80, [MinLod]>;
 971 defm MakeTexelAvailableKHR : ImageOperandOperand<0x100, [VulkanMemoryModelKHR]>;
 972 defm MakeTexelVisibleKHR : ImageOperandOperand<0x200, [VulkanMemoryModelKHR]>;
 973 defm NonPrivateTexelKHR : ImageOperandOperand<0x400, [VulkanMemoryModelKHR]>;
 974 defm VolatileTexelKHR : ImageOperandOperand<0x800, [VulkanMemoryModelKHR]>;
 975 defm SignExtend : ImageOperandOperand<0x1000, []>;
 976 defm ZeroExtend : ImageOperandOperand<0x2000, []>;
 977
 978 //===----------------------------------------------------------------------===//
 979 // Multiclass used to define FPFastMathMode enum values and at the same time
 980 // SymbolicOperand entries with string mnemonics and capabilities.
 981 //===----------------------------------------------------------------------===//
 982
 983 def FPFastMathMode : GenericEnum, Operand<i32> {
 984   let FilterClass = "FPFastMathMode";
 985   let NameField = "Name";
 986   let ValueField = "Value";
 987   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
 988 }
 989
 990 class FPFastMathMode<string name, bits<32> value> {
 991   string Name = name;
 992   bits<32> Value = value;
 993 }
 994
 995 multiclass FPFastMathModeOperand<bits<32> value, list<Capability> reqCapabilities> {
 996   def : FPFastMathMode<NAME, value>;
 997   defm : SymbolicOperandWithRequirements<FPFastMathModeOperand, value, NAME, 0, 0, [], reqCapabilities>;
 998 }
 999
1000 defm None : FPFastMathModeOperand<0x0, []>;
1001 defm NotNaN : FPFastMathModeOperand<0x1, [Kernel]>;
1002 defm NotInf : FPFastMathModeOperand<0x2, [Kernel]>;
1003 defm NSZ : FPFastMathModeOperand<0x4, [Kernel]>;
1004 defm AllowRecip : FPFastMathModeOperand<0x8, [Kernel]>;
1005 defm Fast : FPFastMathModeOperand<0x10, [Kernel]>;
1006
1007 //===----------------------------------------------------------------------===//
1008 // Multiclass used to define FPRoundingMode enum values and at the same time
1009 // SymbolicOperand entries with string mnemonics.
1010 //===----------------------------------------------------------------------===//
1011
1012 def FPRoundingMode : GenericEnum, Operand<i32> {
1013   let FilterClass = "FPRoundingMode";
1014   let NameField = "Name";
1015   let ValueField = "Value";
1016   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1017 }
1018
1019 class FPRoundingMode<string name, bits<32> value> {
1020   string Name = name;
1021   bits<32> Value = value;
1022 }
1023
1024 multiclass FPRoundingModeOperand<bits<32> value> {
1025   def NAME : FPRoundingMode<NAME, value>;
1026   defm : SymbolicOperandWithRequirements<FPRoundingModeOperand, value, NAME, 0, 0, [], []>;
1027 }
1028
1029 defm RTE : FPRoundingModeOperand<0>;
1030 defm RTZ : FPRoundingModeOperand<1>;
1031 defm RTP : FPRoundingModeOperand<2>;
1032 defm RTN : FPRoundingModeOperand<3>;
1033
1034 //===----------------------------------------------------------------------===//
1035 // Multiclass used to define LinkageType enum values and at the same time
1036 // SymbolicOperand entries with string mnemonics and capabilities.
1037 //===----------------------------------------------------------------------===//
1038
1039 def LinkageType : GenericEnum, Operand<i32> {
1040   let FilterClass = "LinkageType";
1041   let NameField = "Name";
1042   let ValueField = "Value";
1043   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1044 }
1045
1046 class LinkageType<string name, bits<32> value> {
1047   string Name = name;
1048   bits<32> Value = value;
1049 }
1050
1051 multiclass LinkageTypeOperand<bits<32> value, list<Capability> reqCapabilities> {
1052   def : LinkageType<NAME, value>;
1053   defm : SymbolicOperandWithRequirements<LinkageTypeOperand, value, NAME, 0, 0, [], reqCapabilities>;
1054 }
1055
1056 defm Export : LinkageTypeOperand<0, [Linkage]>;
1057 defm Import : LinkageTypeOperand<1, [Linkage]>;
1058 defm LinkOnceODR : LinkageTypeOperand<2, [Linkage]>;
1059
1060 //===----------------------------------------------------------------------===//
1061 // Multiclass used to define AccessQualifier enum values and at the same time
1062 // SymbolicOperand entries with string mnemonics and capabilities.
1063 //===----------------------------------------------------------------------===//
1064
1065 def AccessQualifier : GenericEnum, Operand<i32> {
1066   let FilterClass = "AccessQualifier";
1067   let NameField = "Name";
1068   let ValueField = "Value";
1069   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1070 }
1071
1072 class AccessQualifier<string name, bits<32> value> {
1073   string Name = name;
1074   bits<32> Value = value;
1075 }
1076
1077 multiclass AccessQualifierOperand<bits<32> value, list<Capability> reqCapabilities> {
1078   def NAME : AccessQualifier<NAME, value>;
1079   defm : SymbolicOperandWithRequirements<AccessQualifierOperand, value, NAME, 0, 0, [], reqCapabilities>;
1080 }
1081
1082 defm ReadOnly : AccessQualifierOperand<0, [Kernel]>;
1083 defm WriteOnly : AccessQualifierOperand<1, [Kernel]>;
1084 defm ReadWrite : AccessQualifierOperand<2, [Kernel]>;
1085
1086 //===----------------------------------------------------------------------===//
1087 // Multiclass used to define FunctionParameterAttribute enum values and at the
1088 // same time SymbolicOperand entries with string mnemonics and capabilities.
1089 //===----------------------------------------------------------------------===//
1090
1091 def FunctionParameterAttribute : GenericEnum, Operand<i32> {
1092   let FilterClass = "FunctionParameterAttribute";
1093   let NameField = "Name";
1094   let ValueField = "Value";
1095   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1096 }
1097
1098 class FunctionParameterAttribute<string name, bits<32> value> {
1099   string Name = name;
1100   bits<32> Value = value;
1101 }
1102
1103 multiclass FunctionParameterAttributeOperand<bits<32> value, list<Capability> reqCapabilities> {
1104   def : FunctionParameterAttribute<NAME, value>;
1105   defm : SymbolicOperandWithRequirements<FunctionParameterAttributeOperand, value, NAME, 0, 0, [], reqCapabilities>;
1106 }
1107
1108 defm Zext : FunctionParameterAttributeOperand<0, [Kernel]>;
1109 defm Sext : FunctionParameterAttributeOperand<1, [Kernel]>;
1110 defm ByVal : FunctionParameterAttributeOperand<2, [Kernel]>;
1111 defm Sret : FunctionParameterAttributeOperand<3, [Kernel]>;
1112 defm NoAlias : FunctionParameterAttributeOperand<4, [Kernel]>;
1113 defm NoCapture : FunctionParameterAttributeOperand<5, [Kernel]>;
1114 defm NoWrite : FunctionParameterAttributeOperand<6, [Kernel]>;
1115 defm NoReadWrite : FunctionParameterAttributeOperand<7, [Kernel]>;
1116
1117 //===----------------------------------------------------------------------===//
1118 // Multiclass used to define Decoration enum values and at the same time
1119 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1120 // capabilities.
1121 //===----------------------------------------------------------------------===//
1122
1123 def Decoration : GenericEnum, Operand<i32> {
1124   let FilterClass = "Decoration";
1125   let NameField = "Name";
1126   let ValueField = "Value";
1127   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1128 }
1129
1130 class Decoration<string name, bits<32> value> {
1131   string Name = name;
1132   bits<32> Value = value;
1133 }
1134
1135 multiclass DecorationOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1136   def : Decoration<NAME, value>;
1137   defm : SymbolicOperandWithRequirements<DecorationOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1138 }
1139
1140 defm RelaxedPrecision : DecorationOperand<0, 0, 0, [], [Shader]>;
1141 defm SpecId : DecorationOperand<1, 0, 0, [], [Shader, Kernel]>;
1142 defm Block : DecorationOperand<2, 0, 0, [], [Shader]>;
1143 defm BufferBlock : DecorationOperand<3, 0, 0, [], [Shader]>;
1144 defm RowMajor : DecorationOperand<4, 0, 0, [], [Matrix]>;
1145 defm ColMajor : DecorationOperand<5, 0, 0, [], [Matrix]>;
1146 defm ArrayStride : DecorationOperand<6, 0, 0, [], [Shader]>;
1147 defm MatrixStride : DecorationOperand<7, 0, 0, [], [Matrix]>;
1148 defm GLSLShared : DecorationOperand<8, 0, 0, [], [Shader]>;
1149 defm GLSLPacked : DecorationOperand<9, 0, 0, [], [Shader]>;
1150 defm CPacked : DecorationOperand<10, 0, 0, [], [Kernel]>;
1151 defm BuiltIn : DecorationOperand<11, 0, 0, [], []>;
1152 defm NoPerspective : DecorationOperand<13, 0, 0, [], [Shader]>;
1153 defm Flat : DecorationOperand<14, 0, 0, [], [Shader]>;
1154 defm Patch : DecorationOperand<15, 0, 0, [], [Tessellation]>;
1155 defm Centroid : DecorationOperand<16, 0, 0, [], [Shader]>;
1156 defm Sample : DecorationOperand<17, 0, 0, [], [SampleRateShading]>;
1157 defm Invariant : DecorationOperand<18, 0, 0, [], [Shader]>;
1158 defm Restrict : DecorationOperand<19, 0, 0, [], []>;
1159 defm Aliased : DecorationOperand<20, 0, 0, [], []>;
1160 defm Volatile : DecorationOperand<21, 0, 0, [], []>;
1161 defm Constant : DecorationOperand<22, 0, 0, [], [Kernel]>;
1162 defm Coherent : DecorationOperand<23, 0, 0, [], []>;
1163 defm NonWritable : DecorationOperand<24, 0, 0, [], []>;
1164 defm NonReadable : DecorationOperand<25, 0, 0, [], []>;
1165 defm Uniform : DecorationOperand<26, 0, 0, [], [Shader]>;
1166 defm UniformId : DecorationOperand<27, 0, 0, [], [Shader]>;
1167 defm SaturatedConversion : DecorationOperand<28, 0, 0, [], [Kernel]>;
1168 defm Stream : DecorationOperand<29, 0, 0, [], [GeometryStreams]>;
1169 defm Location : DecorationOperand<30, 0, 0, [], [Shader]>;
1170 defm Component : DecorationOperand<31, 0, 0, [], [Shader]>;
1171 defm Index : DecorationOperand<32, 0, 0, [], [Shader]>;
1172 defm Binding : DecorationOperand<33, 0, 0, [], [Shader]>;
1173 defm DescriptorSet : DecorationOperand<34, 0, 0, [], [Shader]>;
1174 defm Offset : DecorationOperand<35, 0, 0, [], [Shader]>;
1175 defm XfbBuffer : DecorationOperand<36, 0, 0, [], [TransformFeedback]>;
1176 defm XfbStride : DecorationOperand<37, 0, 0, [], [TransformFeedback]>;
1177 defm FuncParamAttr : DecorationOperand<38, 0, 0, [], [Kernel]>;
1178 defm FPRoundingMode : DecorationOperand<39, 0, 0, [], []>;
1179 defm FPFastMathMode : DecorationOperand<40, 0, 0, [], [Kernel]>;
1180 defm LinkageAttributes : DecorationOperand<41, 0, 0, [], [Linkage]>;
1181 defm NoContraction : DecorationOperand<42, 0, 0, [], [Shader]>;
1182 defm InputAttachmentIndex : DecorationOperand<43, 0, 0, [], [InputAttachment]>;
1183 defm Alignment : DecorationOperand<44, 0, 0, [], [Kernel]>;
1184 defm MaxByteOffset : DecorationOperand<45, 0, 0, [], [Addresses]>;
1185 defm AlignmentId : DecorationOperand<46, 0, 0, [], [Kernel]>;
1186 defm MaxByteOffsetId : DecorationOperand<47, 0, 0, [], [Addresses]>;
1187 defm NoSignedWrap : DecorationOperand<4469, 0x10400, 0, [SPV_KHR_no_integer_wrap_decoration], []>;
1188 defm NoUnsignedWrap : DecorationOperand<4470, 0x10400, 0, [SPV_KHR_no_integer_wrap_decoration], []>;
1189 defm ExplicitInterpAMD : DecorationOperand<4999, 0, 0, [], []>;
1190 defm OverrideCoverageNV : DecorationOperand<5248, 0, 0, [], [SampleMaskOverrideCoverageNV]>;
1191 defm PassthroughNV : DecorationOperand<5250, 0, 0, [], [GeometryShaderPassthroughNV]>;
1192 defm ViewportRelativeNV : DecorationOperand<5252, 0, 0, [], [ShaderViewportMaskNV]>;
1193 defm SecondaryViewportRelativeNV : DecorationOperand<5256, 0, 0, [], [ShaderStereoViewNV]>;
1194 defm PerPrimitiveNV : DecorationOperand<5271, 0, 0, [], [MeshShadingNV]>;
1195 defm PerViewNV : DecorationOperand<5272, 0, 0, [], [MeshShadingNV]>;
1196 defm PerVertexNV : DecorationOperand<5273, 0, 0, [], [FragmentBarycentricNV]>;
1197 defm NonUniformEXT : DecorationOperand<5300, 0, 0, [], [ShaderNonUniformEXT]>;
1198 defm CountBuffer : DecorationOperand<5634, 0, 0, [], []>;
1199 defm UserSemantic : DecorationOperand<5635, 0, 0, [], []>;
1200 defm RestrictPointerEXT : DecorationOperand<5355, 0, 0, [], [PhysicalStorageBufferAddressesEXT]>;
1201 defm AliasedPointerEXT : DecorationOperand<5356, 0, 0, [], [PhysicalStorageBufferAddressesEXT]>;
1202 defm ReferencedIndirectlyINTEL : DecorationOperand<5602, 0, 0, [], [IndirectReferencesINTEL]>;
1203 defm ArgumentAttributeINTEL : DecorationOperand<6409, 0, 0, [], [FunctionPointersINTEL]>;
1204
1205 //===----------------------------------------------------------------------===//
1206 // Multiclass used to define BuiltIn enum values and at the same time
1207 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1208 // capabilities.
1209 //===----------------------------------------------------------------------===//
1210
1211 def BuiltIn : GenericEnum, Operand<i32> {
1212   let FilterClass = "BuiltIn";
1213   let NameField = "Name";
1214   let ValueField = "Value";
1215   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1216 }
1217
1218 class BuiltIn<string name, bits<32> value> {
1219   string Name = name;
1220   bits<32> Value = value;
1221 }
1222
1223 multiclass BuiltInOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1224   def NAME : BuiltIn<NAME, value>;
1225   defm : SymbolicOperandWithRequirements<BuiltInOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1226 }
1227
1228 defm Position : BuiltInOperand<0, 0, 0, [], [Shader]>;
1229 defm PointSize : BuiltInOperand<1, 0, 0, [], [Shader]>;
1230 defm ClipDistanceVariable : BuiltInOperand<3, 0, 0, [], [ClipDistance]>;
1231 defm CullDistanceVariable : BuiltInOperand<4, 0, 0, [], [CullDistance]>;
1232 defm VertexId : BuiltInOperand<5, 0, 0, [], [Shader]>;
1233 defm InstanceId : BuiltInOperand<6, 0, 0, [], [Shader]>;
1234 defm PrimitiveId : BuiltInOperand<7, 0, 0, [], [Geometry, Tessellation, RayTracingNV]>;
1235 defm InvocationId : BuiltInOperand<8, 0, 0, [], [Geometry, Tessellation]>;
1236 defm Layer : BuiltInOperand<9, 0, 0, [], [Geometry]>;
1237 defm ViewportIndex : BuiltInOperand<10, 0, 0, [], [MultiViewport]>;
1238 defm TessLevelOuter : BuiltInOperand<11, 0, 0, [], [Tessellation]>;
1239 defm TessLevelInner : BuiltInOperand<12, 0, 0, [], [Tessellation]>;
1240 defm TessCoord : BuiltInOperand<13, 0, 0, [], [Tessellation]>;
1241 defm PatchVertices : BuiltInOperand<14, 0, 0, [], [Tessellation]>;
1242 defm FragCoord : BuiltInOperand<15, 0, 0, [], [Shader]>;
1243 defm PointCoord : BuiltInOperand<16, 0, 0, [], [Shader]>;
1244 defm FrontFacing : BuiltInOperand<17, 0, 0, [], [Shader]>;
1245 defm SampleId : BuiltInOperand<18, 0, 0, [], [SampleRateShading]>;
1246 defm SamplePosition : BuiltInOperand<19, 0, 0, [], [SampleRateShading]>;
1247 defm SampleMask : BuiltInOperand<20, 0, 0, [], [Shader]>;
1248 defm FragDepth : BuiltInOperand<22, 0, 0, [], [Shader]>;
1249 defm HelperInvocation : BuiltInOperand<23, 0, 0, [], [Shader]>;
1250 defm NumWorkgroups : BuiltInOperand<24, 0, 0, [], []>;
1251 defm WorkgroupSize : BuiltInOperand<25, 0, 0, [], []>;
1252 defm WorkgroupId : BuiltInOperand<26, 0, 0, [], []>;
1253 defm LocalInvocationId : BuiltInOperand<27, 0, 0, [], []>;
1254 defm GlobalInvocationId : BuiltInOperand<28, 0, 0, [], []>;
1255 defm LocalInvocationIndex : BuiltInOperand<29, 0, 0, [], []>;
1256 defm WorkDim : BuiltInOperand<30, 0, 0, [], [Kernel]>;
1257 defm GlobalSize : BuiltInOperand<31, 0, 0, [], [Kernel]>;
1258 defm EnqueuedWorkgroupSize : BuiltInOperand<32, 0, 0, [], [Kernel]>;
1259 defm GlobalOffset : BuiltInOperand<33, 0, 0, [], [Kernel]>;
1260 defm GlobalLinearId : BuiltInOperand<34, 0, 0, [], [Kernel]>;
1261 defm SubgroupSize : BuiltInOperand<36, 0, 0, [], [Kernel, GroupNonUniform, SubgroupBallotKHR]>;
1262 defm SubgroupMaxSize : BuiltInOperand<37, 0, 0, [], [Kernel]>;
1263 defm NumSubgroups : BuiltInOperand<38, 0, 0, [], [Kernel, GroupNonUniform]>;
1264 defm NumEnqueuedSubgroups : BuiltInOperand<39, 0, 0, [], [Kernel]>;
1265 defm SubgroupId : BuiltInOperand<40, 0, 0, [], [Kernel, GroupNonUniform]>;
1266 defm SubgroupLocalInvocationId : BuiltInOperand<41, 0, 0, [], [Kernel, GroupNonUniform, SubgroupBallotKHR]>;
1267 defm VertexIndex : BuiltInOperand<42, 0, 0, [], [Shader]>;
1268 defm InstanceIndex : BuiltInOperand<43, 0, 0, [], [Shader]>;
1269 defm SubgroupEqMask : BuiltInOperand<4416, 0, 0, [], [SubgroupBallotKHR, GroupNonUniformBallot]>;
1270 defm SubgroupGeMask : BuiltInOperand<4417, 0, 0, [], [SubgroupBallotKHR, GroupNonUniformBallot]>;
1271 defm SubgroupGtMask : BuiltInOperand<4418, 0, 0, [], [SubgroupBallotKHR, GroupNonUniformBallot]>;
1272 defm SubgroupLeMask : BuiltInOperand<4419, 0, 0, [], [SubgroupBallotKHR, GroupNonUniformBallot]>;
1273 defm SubgroupLtMask : BuiltInOperand<4420, 0, 0, [], [SubgroupBallotKHR, GroupNonUniformBallot]>;
1274 defm BaseVertex : BuiltInOperand<4424, 0, 0, [], [DrawParameters]>;
1275 defm BaseInstance : BuiltInOperand<4425, 0, 0, [], [DrawParameters]>;
1276 defm DrawIndex : BuiltInOperand<4426, 0, 0, [], [DrawParameters, MeshShadingNV]>;
1277 defm DeviceIndex : BuiltInOperand<4438, 0, 0, [], [DeviceGroup]>;
1278 defm ViewIndex : BuiltInOperand<4440, 0, 0, [], [MultiView]>;
1279 defm BaryCoordNoPerspAMD : BuiltInOperand<4492, 0, 0, [], []>;
1280 defm BaryCoordNoPerspCentroidAMD : BuiltInOperand<4493, 0, 0, [], []>;
1281 defm BaryCoordNoPerspSampleAMD : BuiltInOperand<4494, 0, 0, [], []>;
1282 defm BaryCoordSmoothAMD : BuiltInOperand<4495, 0, 0, [], []>;
1283 defm BaryCoordSmoothCentroid : BuiltInOperand<4496, 0, 0, [], []>;
1284 defm BaryCoordSmoothSample : BuiltInOperand<4497, 0, 0, [], []>;
1285 defm BaryCoordPullModel : BuiltInOperand<4498, 0, 0, [], []>;
1286 defm FragStencilRefEXT : BuiltInOperand<5014, 0, 0, [], [StencilExportEXT]>;
1287 defm ViewportMaskNV : BuiltInOperand<5253, 0, 0, [], [ShaderViewportMaskNV, MeshShadingNV]>;
1288 defm SecondaryPositionNV : BuiltInOperand<5257, 0, 0, [], [ShaderStereoViewNV]>;
1289 defm SecondaryViewportMaskNV : BuiltInOperand<5258, 0, 0, [], [ShaderStereoViewNV]>;
1290 defm PositionPerViewNV : BuiltInOperand<5261, 0, 0, [], [PerViewAttributesNV, MeshShadingNV]>;
1291 defm ViewportMaskPerViewNV : BuiltInOperand<5262, 0, 0, [], [PerViewAttributesNV, MeshShadingNV]>;
1292 defm FullyCoveredEXT : BuiltInOperand<5264, 0, 0, [], [FragmentFullyCoveredEXT]>;
1293 defm TaskCountNV : BuiltInOperand<5274, 0, 0, [], [MeshShadingNV]>;
1294 defm PrimitiveCountNV : BuiltInOperand<5275, 0, 0, [], [MeshShadingNV]>;
1295 defm PrimitiveIndicesNV : BuiltInOperand<5276, 0, 0, [], [MeshShadingNV]>;
1296 defm ClipDistancePerViewNV : BuiltInOperand<5277, 0, 0, [], [MeshShadingNV]>;
1297 defm CullDistancePerViewNV : BuiltInOperand<5278, 0, 0, [], [MeshShadingNV]>;
1298 defm LayerPerViewNV : BuiltInOperand<5279, 0, 0, [], [MeshShadingNV]>;
1299 defm MeshViewCountNV : BuiltInOperand<5280, 0, 0, [], [MeshShadingNV]>;
1300 defm MeshViewIndices : BuiltInOperand<5281, 0, 0, [], [MeshShadingNV]>;
1301 defm BaryCoordNV : BuiltInOperand<5286, 0, 0, [], [FragmentBarycentricNV]>;
1302 defm BaryCoordNoPerspNV : BuiltInOperand<5287, 0, 0, [], [FragmentBarycentricNV]>;
1303 defm FragSizeEXT : BuiltInOperand<5292, 0, 0, [], [FragmentDensityEXT]>;
1304 defm FragInvocationCountEXT : BuiltInOperand<5293, 0, 0, [], [FragmentDensityEXT]>;
1305 defm LaunchIdNV : BuiltInOperand<5319, 0, 0, [], [RayTracingNV]>;
1306 defm LaunchSizeNV : BuiltInOperand<5320, 0, 0, [], [RayTracingNV]>;
1307 defm WorldRayOriginNV : BuiltInOperand<5321, 0, 0, [], [RayTracingNV]>;
1308 defm WorldRayDirectionNV : BuiltInOperand<5322, 0, 0, [], [RayTracingNV]>;
1309 defm ObjectRayOriginNV : BuiltInOperand<5323, 0, 0, [], [RayTracingNV]>;
1310 defm ObjectRayDirectionNV : BuiltInOperand<5324, 0, 0, [], [RayTracingNV]>;
1311 defm RayTminNV : BuiltInOperand<5325, 0, 0, [], [RayTracingNV]>;
1312 defm RayTmaxNV : BuiltInOperand<5326, 0, 0, [], [RayTracingNV]>;
1313 defm InstanceCustomIndexNV : BuiltInOperand<5327, 0, 0, [], [RayTracingNV]>;
1314 defm ObjectToWorldNV : BuiltInOperand<5330, 0, 0, [], [RayTracingNV]>;
1315 defm WorldToObjectNV : BuiltInOperand<5331, 0, 0, [], [RayTracingNV]>;
1316 defm HitTNV : BuiltInOperand<5332, 0, 0, [], [RayTracingNV]>;
1317 defm HitKindNV : BuiltInOperand<5333, 0, 0, [], [RayTracingNV]>;
1318 defm IncomingRayFlagsNV : BuiltInOperand<5351, 0, 0, [], [RayTracingNV]>;
1319
1320 //===----------------------------------------------------------------------===//
1321 // Multiclass used to define SelectionControl enum values and at the same time
1322 // SymbolicOperand entries with string mnemonics.
1323 //===----------------------------------------------------------------------===//
1324
1325 def SelectionControl : GenericEnum, Operand<i32> {
1326   let FilterClass = "SelectionControl";
1327   let NameField = "Name";
1328   let ValueField = "Value";
1329   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1330 }
1331
1332 class SelectionControl<string name, bits<32> value> {
1333   string Name = name;
1334   bits<32> Value = value;
1335 }
1336
1337 multiclass SelectionControlOperand<bits<32> value> {
1338   def : SelectionControl<NAME, value>;
1339   defm : SymbolicOperandWithRequirements<SelectionControlOperand, value, NAME, 0, 0, [], []>;
1340 }
1341
1342 defm None : SelectionControlOperand<0x0>;
1343 defm Flatten : SelectionControlOperand<0x1>;
1344 defm DontFlatten : SelectionControlOperand<0x2>;
1345
1346 //===----------------------------------------------------------------------===//
1347 // Multiclass used to define LoopControl enum values and at the same time
1348 // SymbolicOperand entries with string mnemonics.
1349 //===----------------------------------------------------------------------===//
1350
1351 def LoopControl : GenericEnum, Operand<i32> {
1352   let FilterClass = "LoopControl";
1353   let NameField = "Name";
1354   let ValueField = "Value";
1355   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1356 }
1357
1358 class LoopControl<string name, bits<32> value> {
1359   string Name = name;
1360   bits<32> Value = value;
1361 }
1362
1363 multiclass LoopControlOperand<bits<32> value> {
1364   def : LoopControl<NAME, value>;
1365   defm : SymbolicOperandWithRequirements<LoopControlOperand, value, NAME, 0, 0, [], []>;
1366 }
1367
1368 defm None : LoopControlOperand<0x0>;
1369 defm Unroll : LoopControlOperand<0x1>;
1370 defm DontUnroll : LoopControlOperand<0x2>;
1371 defm DependencyInfinite : LoopControlOperand<0x4>;
1372 defm DependencyLength : LoopControlOperand<0x8>;
1373 defm MinIterations : LoopControlOperand<0x10>;
1374 defm MaxIterations : LoopControlOperand<0x20>;
1375 defm IterationMultiple : LoopControlOperand<0x40>;
1376 defm PeelCount : LoopControlOperand<0x80>;
1377 defm PartialCount : LoopControlOperand<0x100>;
1378
1379 //===----------------------------------------------------------------------===//
1380 // Multiclass used to define FunctionControl enum values and at the same time
1381 // SymbolicOperand entries with string mnemonics.
1382 //===----------------------------------------------------------------------===//
1383
1384 def FunctionControl : GenericEnum, Operand<i32> {
1385   let FilterClass = "FunctionControl";
1386   let NameField = "Name";
1387   let ValueField = "Value";
1388   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1389 }
1390
1391 class FunctionControl<string name, bits<32> value> {
1392   string Name = name;
1393   bits<32> Value = value;
1394 }
1395
1396 multiclass FunctionControlOperand<bits<32> value> {
1397   def : FunctionControl<NAME, value>;
1398   defm : SymbolicOperandWithRequirements<FunctionControlOperand, value, NAME, 0, 0, [], []>;
1399 }
1400
1401 defm None : FunctionControlOperand<0x0>;
1402 defm Inline : FunctionControlOperand<0x1>;
1403 defm DontInline : FunctionControlOperand<0x2>;
1404 defm Pure : FunctionControlOperand<0x4>;
1405 defm Const : FunctionControlOperand<0x8>;
1406
1407 //===----------------------------------------------------------------------===//
1408 // Multiclass used to define MemorySemantics enum values and at the same time
1409 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1410 // capabilities.
1411 //===----------------------------------------------------------------------===//
1412
1413 def MemorySemantics : GenericEnum, Operand<i32> {
1414   let FilterClass = "MemorySemantics";
1415   let NameField = "Name";
1416   let ValueField = "Value";
1417   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1418 }
1419
1420 class MemorySemantics<string name, bits<32> value> {
1421   string Name = name;
1422   bits<32> Value = value;
1423 }
1424
1425 multiclass MemorySemanticsOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1426   def : MemorySemantics<NAME, value>;
1427   defm : SymbolicOperandWithRequirements<MemorySemanticsOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1428 }
1429
1430 defm None : MemorySemanticsOperand<0x0, 0, 0, [], []>;
1431 defm Acquire : MemorySemanticsOperand<0x2, 0, 0, [], []>;
1432 defm Release : MemorySemanticsOperand<0x4, 0, 0, [], []>;
1433 defm AcquireRelease : MemorySemanticsOperand<0x8, 0, 0, [], []>;
1434 defm SequentiallyConsistent : MemorySemanticsOperand<0x10, 0, 0, [], []>;
1435 defm UniformMemory : MemorySemanticsOperand<0x40, 0, 0, [], [Shader]>;
1436 defm SubgroupMemory : MemorySemanticsOperand<0x80, 0, 0, [], []>;
1437 defm WorkgroupMemory : MemorySemanticsOperand<0x100, 0, 0, [], []>;
1438 defm CrossWorkgroupMemory : MemorySemanticsOperand<0x200, 0, 0, [], []>;
1439 defm AtomicCounterMemory : MemorySemanticsOperand<0x400, 0, 0, [], [AtomicStorage]>;
1440 defm ImageMemory : MemorySemanticsOperand<0x800, 0, 0, [], []>;
1441 defm OutputMemoryKHR : MemorySemanticsOperand<0x1000, 0, 0, [], [VulkanMemoryModelKHR]>;
1442 defm MakeAvailableKHR : MemorySemanticsOperand<0x2000, 0, 0, [], [VulkanMemoryModelKHR]>;
1443 defm MakeVisibleKHR : MemorySemanticsOperand<0x4000, 0, 0, [], [VulkanMemoryModelKHR]>;
1444
1445 //===----------------------------------------------------------------------===//
1446 // Multiclass used to define MemoryOperand enum values and at the same time
1447 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1448 // capabilities.
1449 //===----------------------------------------------------------------------===//
1450
1451 def MemoryOperand : GenericEnum, Operand<i32> {
1452   let FilterClass = "MemoryOperand";
1453   let NameField = "Name";
1454   let ValueField = "Value";
1455   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1456 }
1457
1458 class MemoryOperand<string name, bits<32> value> {
1459   string Name = name;
1460   bits<32> Value = value;
1461 }
1462
1463 multiclass MemoryOperandOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1464   def : MemoryOperand<NAME, value>;
1465   defm : SymbolicOperandWithRequirements<MemoryOperandOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1466 }
1467
1468 defm None : MemoryOperandOperand<0x0, 0, 0, [], []>;
1469 defm Volatile : MemoryOperandOperand<0x1, 0, 0, [], []>;
1470 defm Aligned : MemoryOperandOperand<0x2, 0, 0, [], []>;
1471 defm Nontemporal : MemoryOperandOperand<0x4, 0, 0, [], []>;
1472 defm MakePointerAvailableKHR : MemoryOperandOperand<0x8, 0, 0, [], [VulkanMemoryModelKHR]>;
1473 defm MakePointerVisibleKHR : MemoryOperandOperand<0x10, 0, 0, [], [VulkanMemoryModelKHR]>;
1474 defm NonPrivatePointerKHR : MemoryOperandOperand<0x20, 0, 0, [], [VulkanMemoryModelKHR]>;
1475
1476 //===----------------------------------------------------------------------===//
1477 // Multiclass used to define Scope enum values and at the same time
1478 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1479 // capabilities.
1480 //===----------------------------------------------------------------------===//
1481
1482 def Scope : GenericEnum, Operand<i32> {
1483   let FilterClass = "Scope";
1484   let NameField = "Name";
1485   let ValueField = "Value";
1486   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1487 }
1488
1489 class Scope<string name, bits<32> value> {
1490   string Name = name;
1491   bits<32> Value = value;
1492 }
1493
1494 multiclass ScopeOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1495   def : Scope<NAME, value>;
1496   defm : SymbolicOperandWithRequirements<ScopeOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1497 }
1498
1499 defm CrossDevice : ScopeOperand<0, 0, 0, [], []>;
1500 defm Device : ScopeOperand<1, 0, 0, [], []>;
1501 defm Workgroup : ScopeOperand<2, 0, 0, [], []>;
1502 defm Subgroup : ScopeOperand<3, 0, 0, [], []>;
1503 defm Invocation : ScopeOperand<4, 0, 0, [], []>;
1504 defm QueueFamilyKHR : ScopeOperand<5, 0, 0, [], [VulkanMemoryModelKHR]>;
1505
1506 //===----------------------------------------------------------------------===//
1507 // Multiclass used to define GroupOperation enum values and at the same time
1508 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1509 // capabilities.
1510 //===----------------------------------------------------------------------===//
1511
1512 def GroupOperation : GenericEnum, Operand<i32> {
1513   let FilterClass = "GroupOperation";
1514   let NameField = "Name";
1515   let ValueField = "Value";
1516   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1517 }
1518
1519 class GroupOperation<string name, bits<32> value> {
1520   string Name = name;
1521   bits<32> Value = value;
1522 }
1523
1524 multiclass GroupOperationOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1525   def NAME : GroupOperation<NAME, value>;
1526   defm : SymbolicOperandWithRequirements<GroupOperationOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1527 }
1528
1529 defm Reduce : GroupOperationOperand<0, 0, 0, [], [Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot]>;
1530 defm InclusiveScan : GroupOperationOperand<1, 0, 0, [], [Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot]>;
1531 defm ExclusiveScan : GroupOperationOperand<2, 0, 0, [], [Kernel, GroupNonUniformArithmetic, GroupNonUniformBallot]>;
1532 defm ClusteredReduce : GroupOperationOperand<3, 0, 0, [], [GroupNonUniformClustered]>;
1533 defm PartitionedReduceNV : GroupOperationOperand<6, 0, 0, [], [GroupNonUniformPartitionedNV]>;
1534 defm PartitionedInclusiveScanNV : GroupOperationOperand<7, 0, 0, [], [GroupNonUniformPartitionedNV]>;
1535 defm PartitionedExclusiveScanNV : GroupOperationOperand<8, 0, 0, [], [GroupNonUniformPartitionedNV]>;
1536
1537 //===----------------------------------------------------------------------===//
1538 // Multiclass used to define KernelEnqueueFlags enum values and at the same time
1539 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1540 // capabilities.
1541 //===----------------------------------------------------------------------===//
1542
1543 def KernelEnqueueFlags : GenericEnum, Operand<i32> {
1544   let FilterClass = "KernelEnqueueFlags";
1545   let NameField = "Name";
1546   let ValueField = "Value";
1547   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1548 }
1549
1550 class KernelEnqueueFlags<string name, bits<32> value> {
1551   string Name = name;
1552   bits<32> Value = value;
1553 }
1554
1555 multiclass KernelEnqueueFlagsOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1556   def : KernelEnqueueFlags<NAME, value>;
1557   defm : SymbolicOperandWithRequirements<KernelEnqueueFlagsOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1558 }
1559
1560 defm NoWait : KernelEnqueueFlagsOperand<0, 0, 0, [], [Kernel]>;
1561 defm WaitKernel : KernelEnqueueFlagsOperand<1, 0, 0, [], [Kernel]>;
1562 defm WaitWorkGroup : KernelEnqueueFlagsOperand<2, 0, 0, [], [Kernel]>;
1563
1564 //===----------------------------------------------------------------------===//
1565 // Multiclass used to define KernelProfilingInfo enum values and at the same time
1566 // SymbolicOperand entries with string mnemonics, versioning, extensions and
1567 // capabilities.
1568 //===----------------------------------------------------------------------===//
1569
1570 def KernelProfilingInfo : GenericEnum, Operand<i32> {
1571   let FilterClass = "KernelProfilingInfo";
1572   let NameField = "Name";
1573   let ValueField = "Value";
1574   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1575 }
1576
1577 class KernelProfilingInfo<string name, bits<32> value> {
1578   string Name = name;
1579   bits<32> Value = value;
1580 }
1581
1582 multiclass KernelProfilingInfoOperand<bits<32> value, bits<32> minVersion, bits<32> maxVersion, list<Extension> reqExtensions, list<Capability> reqCapabilities> {
1583   def : KernelProfilingInfo<NAME, value>;
1584   defm : SymbolicOperandWithRequirements<KernelProfilingInfoOperand, value, NAME, minVersion, maxVersion, reqExtensions, reqCapabilities>;
1585 }
1586
1587 defm None : KernelProfilingInfoOperand<0x0, 0, 0, [], []>;
1588 defm CmdExecTime : KernelProfilingInfoOperand<0x1, 0, 0, [], [Kernel]>;
1589
1590 //===----------------------------------------------------------------------===//
1591 // Multiclass used to define Opcode enum values and at the same time
1592 // SymbolicOperand entries with string mnemonics and capabilities.
1593 //===----------------------------------------------------------------------===//
1594
1595 def Opcode : GenericEnum, Operand<i32> {
1596   let FilterClass = "Opcode";
1597   let NameField = "Name";
1598   let ValueField = "Value";
1599   let PrintMethod = !strconcat("printSymbolicOperand<OperandCategory::", FilterClass, "Operand>");
1600 }
1601
1602 class Opcode<string name, bits<32> value> {
1603   string Name = name;
1604   bits<32> Value = value;
1605 }
1606
1607 multiclass OpcodeOperand<bits<32> value> {
1608   def : Opcode<NAME, value>;
1609   defm : SymbolicOperandWithRequirements<OpcodeOperand, value, NAME, 0, 0, [], []>;
1610 }
1611 // TODO: implement other mnemonics.
1612 defm InBoundsPtrAccessChain : OpcodeOperand<70>;
1613 defm PtrCastToGeneric : OpcodeOperand<121>;
1614 defm Bitcast : OpcodeOperand<124>;
1615 defm ConvertPtrToU : OpcodeOperand<117>;
1616 defm ConvertUToPtr : OpcodeOperand<120>;