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