diff --git a/src/codegen/spirv.zig b/src/codegen/spirv.zig index 0b6951ab4fdc..7117ae7e7a2f 100644 --- a/src/codegen/spirv.zig +++ b/src/codegen/spirv.zig @@ -30,6 +30,8 @@ const SpvAssembler = @import("spirv/Assembler.zig"); const InstMap = std.AutoHashMapUnmanaged(Air.Inst.Index, IdRef); +pub const zig_call_abi_ver = 3; + /// We want to store some extra facts about types as mapped from Zig to SPIR-V. /// This structure is used to keep that extra information, as well as /// the cached reference to the type. @@ -252,15 +254,18 @@ pub const Object = struct { /// Note: Function does not actually generate the decl, it just allocates an index. pub fn resolveDecl(self: *Object, mod: *Module, decl_index: InternPool.DeclIndex) !SpvModule.Decl.Index { const decl = mod.declPtr(decl_index); + assert(decl.has_tv); // TODO: Do we need to handle a situation where this is false? try mod.markDeclAlive(decl); const entry = try self.decl_link.getOrPut(self.gpa, decl_index); if (!entry.found_existing) { // TODO: Extern fn? - const kind: SpvModule.DeclKind = if (decl.val.isFuncBody(mod)) + const kind: SpvModule.Decl.Kind = if (decl.val.isFuncBody(mod)) .func - else - .global; + else switch (decl.@"addrspace") { + .generic => .invocation_global, + else => .global, + }; entry.value_ptr.* = try self.spv.allocDecl(kind); } @@ -443,87 +448,90 @@ const DeclGen = struct { return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage. } - fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index, storage_class: StorageClass) !IdRef { + fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index) !IdRef { // TODO: This cannot be a function at this point, but it should probably be handled anyway. + + const mod = self.module; + const ty = Type.fromInterned(mod.intern_pool.typeOf(val)); + const decl_ptr_ty_ref = try self.ptrType(ty, .Generic); + const spv_decl_index = blk: { - const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, storage_class }); + const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, .Function }); if (entry.found_existing) { - try self.addFunctionDep(entry.value_ptr.*, storage_class); - return self.spv.declPtr(entry.value_ptr.*).result_id; + try self.addFunctionDep(entry.value_ptr.*, .Function); + + const result_id = self.spv.declPtr(entry.value_ptr.*).result_id; + return try self.castToGeneric(self.typeId(decl_ptr_ty_ref), result_id); } - const spv_decl_index = try self.spv.allocDecl(.global); - try self.addFunctionDep(spv_decl_index, storage_class); + const spv_decl_index = try self.spv.allocDecl(.invocation_global); + try self.addFunctionDep(spv_decl_index, .Function); entry.value_ptr.* = spv_decl_index; break :blk spv_decl_index; }; - const mod = self.module; - const ty = Type.fromInterned(mod.intern_pool.typeOf(val)); - const ptr_ty_ref = try self.ptrType(ty, storage_class); - - const var_id = self.spv.declPtr(spv_decl_index).result_id; - - const section = &self.spv.sections.types_globals_constants; - try section.emit(self.spv.gpa, .OpVariable, .{ - .id_result_type = self.typeId(ptr_ty_ref), - .id_result = var_id, - .storage_class = storage_class, - }); - // TODO: At some point we will be able to generate this all constant here, but then all of // constant() will need to be implemented such that it doesn't generate any at-runtime code. // NOTE: Because this is a global, we really only want to initialize it once. Therefore the - // constant lowering of this value will need to be deferred to some other function, which - // is then added to the list of initializers using endGlobal(). + // constant lowering of this value will need to be deferred to an initializer similar to + // other globals. - // Save the current state so that we can temporarily generate into a different function. - // TODO: This should probably be made a little more robust. - const func = self.func; - defer self.func = func; - const block_label = self.current_block_label; - defer self.current_block_label = block_label; + const result_id = self.spv.declPtr(spv_decl_index).result_id; - self.func = .{}; - defer self.func.deinit(self.gpa); + { + // Save the current state so that we can temporarily generate into a different function. + // TODO: This should probably be made a little more robust. + const func = self.func; + defer self.func = func; + const block_label = self.current_block_label; + defer self.current_block_label = block_label; - // TODO: Merge this with genDecl? - const begin = self.spv.beginGlobal(); + self.func = .{}; + defer self.func.deinit(self.gpa); - const void_ty_ref = try self.resolveType(Type.void, .direct); - const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ - .return_type = void_ty_ref, - .parameters = &.{}, - } }); + const void_ty_ref = try self.resolveType(Type.void, .direct); + const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ + .return_type = void_ty_ref, + .parameters = &.{}, + } }); - const initializer_id = self.spv.allocId(); - try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ - .id_result_type = self.typeId(void_ty_ref), - .id_result = initializer_id, - .function_control = .{}, - .function_type = self.typeId(initializer_proto_ty_ref), - }); - const root_block_id = self.spv.allocId(); - try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ - .id_result = root_block_id, - }); - self.current_block_label = root_block_id; + const initializer_id = self.spv.allocId(); - const val_id = try self.constant(ty, Value.fromInterned(val), .indirect); - try self.func.body.emit(self.spv.gpa, .OpStore, .{ - .pointer = var_id, - .object = val_id, - }); + try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ + .id_result_type = self.typeId(void_ty_ref), + .id_result = initializer_id, + .function_control = .{}, + .function_type = self.typeId(initializer_proto_ty_ref), + }); + const root_block_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ + .id_result = root_block_id, + }); + self.current_block_label = root_block_id; - self.spv.endGlobal(spv_decl_index, begin, var_id, initializer_id); - try self.func.body.emit(self.spv.gpa, .OpReturn, {}); - try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); - try self.spv.addFunction(spv_decl_index, self.func); + const val_id = try self.constant(ty, Value.fromInterned(val), .indirect); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = result_id, + .object = val_id, + }); - try self.spv.debugNameFmt(var_id, "__anon_{d}", .{@intFromEnum(val)}); - try self.spv.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@intFromEnum(val)}); + try self.func.body.emit(self.spv.gpa, .OpReturn, {}); + try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); + try self.spv.addFunction(spv_decl_index, self.func); + + try self.spv.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@intFromEnum(val)}); + + const fn_decl_ptr_ty_ref = try self.ptrType(ty, .Function); + try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpExtInst, .{ + .id_result_type = self.typeId(fn_decl_ptr_ty_ref), + .id_result = result_id, + .set = try self.spv.importInstructionSet(.zig), + .instruction = .{ .inst = 0 }, // TODO: Put this definition somewhere... + .id_ref_4 = &.{initializer_id}, + }); + } - return var_id; + return try self.castToGeneric(self.typeId(decl_ptr_ty_ref), result_id); } fn addFunctionDep(self: *DeclGen, decl_index: SpvModule.Decl.Index, storage_class: StorageClass) !void { @@ -768,18 +776,75 @@ const DeclGen = struct { }; } - /// Construct a composite value at runtime. If the parameters are in direct - /// representation, then the result is also in direct representation. Otherwise, - /// if the parameters are in indirect representation, then the result is too. - fn constructComposite(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef { - const constituents_id = self.spv.allocId(); - const type_id = try self.resolveType(ty, .direct); - try self.func.body.emit(self.spv.gpa, .OpCompositeConstruct, .{ - .id_result_type = self.typeId(type_id), - .id_result = constituents_id, - .constituents = constituents, - }); - return constituents_id; + /// Construct a struct at runtime. + /// ty must be a struct type. + /// Constituents should be in `indirect` representation (as the elements of a struct should be). + /// Result is in `direct` representation. + fn constructStruct(self: *DeclGen, ty: Type, types: []const Type, constituents: []const IdRef) !IdRef { + assert(types.len == constituents.len); + // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which' + // operands are not constant. + // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349 + // For now, just initialize the struct by setting the fields manually... + // TODO: Make this OpCompositeConstruct when we can + const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function }); + for (constituents, types, 0..) |constitent_id, member_ty, index| { + const ptr_member_ty_ref = try self.ptrType(member_ty, .Function); + const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))}); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = ptr_id, + .object = constitent_id, + }); + } + return try self.load(ty, ptr_composite_id, .{}); + } + + /// Construct a vector at runtime. + /// ty must be an vector type. + /// Constituents should be in `indirect` representation (as the elements of an vector should be). + /// Result is in `direct` representation. + fn constructVector(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef { + // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which' + // operands are not constant. + // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349 + // For now, just initialize the struct by setting the fields manually... + // TODO: Make this OpCompositeConstruct when we can + const mod = self.module; + const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function }); + const ptr_elem_ty_ref = try self.ptrType(ty.elemType2(mod), .Function); + for (constituents, 0..) |constitent_id, index| { + const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))}); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = ptr_id, + .object = constitent_id, + }); + } + + return try self.load(ty, ptr_composite_id, .{}); + } + + /// Construct an array at runtime. + /// ty must be an array type. + /// Constituents should be in `indirect` representation (as the elements of an array should be). + /// Result is in `direct` representation. + fn constructArray(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef { + // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which' + // operands are not constant. + // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349 + // For now, just initialize the struct by setting the fields manually... + // TODO: Make this OpCompositeConstruct when we can + const mod = self.module; + const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function }); + const ptr_elem_ty_ref = try self.ptrType(ty.elemType2(mod), .Function); + for (constituents, 0..) |constitent_id, index| { + const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))}); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = ptr_id, + .object = constitent_id, + }); + } + + return try self.load(ty, ptr_composite_id, .{}); } /// This function generates a load for a constant in direct (ie, non-memory) representation. @@ -887,15 +952,18 @@ const DeclGen = struct { }); var constituents: [2]IdRef = undefined; + var types: [2]Type = undefined; if (eu_layout.error_first) { constituents[0] = try self.constant(err_ty, err_val, .indirect); constituents[1] = try self.constant(payload_ty, payload_val, .indirect); + types = .{ err_ty, payload_ty }; } else { constituents[0] = try self.constant(payload_ty, payload_val, .indirect); constituents[1] = try self.constant(err_ty, err_val, .indirect); + types = .{ payload_ty, err_ty }; } - return try self.constructComposite(ty, &constituents); + return try self.constructStruct(ty, &types, &constituents); }, .enum_tag => { const int_val = try val.intFromEnum(ty, mod); @@ -907,7 +975,11 @@ const DeclGen = struct { const ptr_ty = ty.slicePtrFieldType(mod); const ptr_id = try self.constantPtr(ptr_ty, Value.fromInterned(slice.ptr)); const len_id = try self.constant(Type.usize, Value.fromInterned(slice.len), .indirect); - return self.constructComposite(ty, &.{ ptr_id, len_id }); + return self.constructStruct( + ty, + &.{ ptr_ty, Type.usize }, + &.{ ptr_id, len_id }, + ); }, .opt => { const payload_ty = ty.optionalChild(mod); @@ -934,7 +1006,11 @@ const DeclGen = struct { else try self.spv.constUndef(try self.resolveType(payload_ty, .indirect)); - return try self.constructComposite(ty, &.{ payload_id, has_pl_id }); + return try self.constructStruct( + ty, + &.{ payload_ty, Type.bool }, + &.{ payload_id, has_pl_id }, + ); }, .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) { inline .array_type, .vector_type => |array_type, tag| { @@ -971,9 +1047,9 @@ const DeclGen = struct { const sentinel = Value.fromInterned(array_type.sentinel); constituents[constituents.len - 1] = try self.constant(elem_ty, sentinel, .indirect); } - return self.constructComposite(ty, constituents); + return self.constructArray(ty, constituents); }, - inline .vector_type => return self.constructComposite(ty, constituents), + inline .vector_type => return self.constructVector(ty, constituents), else => unreachable, } }, @@ -983,6 +1059,9 @@ const DeclGen = struct { return self.todo("packed struct constants", .{}); } + var types = std.ArrayList(Type).init(self.gpa); + defer types.deinit(); + var constituents = std.ArrayList(IdRef).init(self.gpa); defer constituents.deinit(); @@ -998,10 +1077,11 @@ const DeclGen = struct { const field_val = try val.fieldValue(mod, field_index); const field_id = try self.constant(field_ty, field_val, .indirect); + try types.append(field_ty); try constituents.append(field_id); } - return try self.constructComposite(ty, constituents.items); + return try self.constructStruct(ty, types.items, constituents.items); }, .anon_struct_type => unreachable, // TODO else => unreachable, @@ -1107,19 +1187,10 @@ const DeclGen = struct { unreachable; // TODO } - const final_storage_class = self.spvStorageClass(ty.ptrAddressSpace(mod)); - const actual_storage_class = switch (final_storage_class) { - .Generic => .CrossWorkgroup, - else => |other| other, - }; - - const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class); - const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class); - - const ptr_id = switch (final_storage_class) { - .Generic => try self.castToGeneric(self.typeId(decl_ptr_ty_ref), decl_id), - else => decl_id, - }; + // Anon decl refs are always generic. + assert(ty.ptrAddressSpace(mod) == .generic); + const decl_ptr_ty_ref = try self.ptrType(decl_ty, .Generic); + const ptr_id = try self.resolveAnonDecl(decl_val); if (decl_ptr_ty_ref != ty_ref) { // Differing pointer types, insert a cast. @@ -1157,8 +1228,13 @@ const DeclGen = struct { } const spv_decl_index = try self.object.resolveDecl(mod, decl_index); + const spv_decl = self.spv.declPtr(spv_decl_index); + + const decl_id = switch (spv_decl.kind) { + .func => unreachable, // TODO: Is this possible? + .global, .invocation_global => spv_decl.result_id, + }; - const decl_id = self.spv.declPtr(spv_decl_index).result_id; const final_storage_class = self.spvStorageClass(decl.@"addrspace"); try self.addFunctionDep(spv_decl_index, final_storage_class); @@ -1437,6 +1513,13 @@ const DeclGen = struct { if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref; const fn_info = mod.typeToFunc(ty).?; + + comptime assert(zig_call_abi_ver == 3); + switch (fn_info.cc) { + .Unspecified, .Kernel, .Fragment, .Vertex, .C => {}, + else => unreachable, // TODO + } + // TODO: Put this somewhere in Sema.zig if (fn_info.is_var_args) return self.fail("VarArgs functions are unsupported for SPIR-V", .{}); @@ -1841,7 +1924,7 @@ const DeclGen = struct { for (wip.results) |*result| { result.* = try wip.dg.convertToIndirect(wip.ty, result.*); } - return try wip.dg.constructComposite(wip.result_ty, wip.results); + return try wip.dg.constructArray(wip.result_ty, wip.results); } else { return wip.results[0]; } @@ -1884,13 +1967,15 @@ const DeclGen = struct { /// (anyerror!void has the same layout as anyerror). /// Each test declaration generates a function like. /// %anyerror = OpTypeInt 0 16 + /// %p_invocation_globals_struct_ty = ... /// %p_anyerror = OpTypePointer CrossWorkgroup %anyerror - /// %K = OpTypeFunction %void %p_anyerror + /// %K = OpTypeFunction %void %p_invocation_globals_struct_ty %p_anyerror /// /// %test = OpFunction %void %K + /// %p_invocation_globals = OpFunctionParameter p_invocation_globals_struct_ty /// %p_err = OpFunctionParameter %p_anyerror /// %lbl = OpLabel - /// %result = OpFunctionCall %anyerror %func + /// %result = OpFunctionCall %anyerror %func %p_invocation_globals /// OpStore %p_err %result /// OpFunctionEnd /// TODO is to also write out the error as a function call parameter, and to somehow fetch @@ -1900,10 +1985,12 @@ const DeclGen = struct { const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup); const void_ty_ref = try self.resolveType(Type.void, .direct); - const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ - .return_type = void_ty_ref, - .parameters = &.{ptr_anyerror_ty_ref}, - } }); + const kernel_proto_ty_ref = try self.spv.resolve(.{ + .function_type = .{ + .return_type = void_ty_ref, + .parameters = &.{ptr_anyerror_ty_ref}, + }, + }); const test_id = self.spv.declPtr(spv_test_decl_index).result_id; @@ -1954,147 +2041,164 @@ const DeclGen = struct { const ip = &mod.intern_pool; const decl = mod.declPtr(self.decl_index); const spv_decl_index = try self.object.resolveDecl(mod, self.decl_index); - const target = self.getTarget(); + const result_id = self.spv.declPtr(spv_decl_index).result_id; - const decl_id = self.spv.declPtr(spv_decl_index).result_id; + switch (self.spv.declPtr(spv_decl_index).kind) { + .func => { + assert(decl.ty.zigTypeTag(mod) == .Fn); + const fn_info = mod.typeToFunc(decl.ty).?; + const return_ty_ref = try self.resolveFnReturnType(Type.fromInterned(fn_info.return_type)); - if (decl.val.getFunction(mod)) |_| { - assert(decl.ty.zigTypeTag(mod) == .Fn); - const fn_info = mod.typeToFunc(decl.ty).?; - const return_ty_ref = try self.resolveFnReturnType(Type.fromInterned(fn_info.return_type)); + const prototype_ty_ref = try self.resolveType(decl.ty, .direct); + try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ + .id_result_type = self.typeId(return_ty_ref), + .id_result = result_id, + .function_control = switch (fn_info.cc) { + .Inline => .{ .Inline = true }, + else => .{}, + }, + .function_type = self.typeId(prototype_ty_ref), + }); - const prototype_id = try self.resolveTypeId(decl.ty); - try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ - .id_result_type = self.typeId(return_ty_ref), - .id_result = decl_id, - .function_control = switch (fn_info.cc) { - .Inline => .{ .Inline = true }, - else => .{}, - }, - .function_type = prototype_id, - }); + comptime assert(zig_call_abi_ver == 3); + try self.args.ensureUnusedCapacity(self.gpa, fn_info.param_types.len); + for (fn_info.param_types.get(ip)) |param_ty_index| { + const param_ty = Type.fromInterned(param_ty_index); + if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue; + + const param_type_id = try self.resolveTypeId(param_ty); + const arg_result_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpFunctionParameter, .{ + .id_result_type = param_type_id, + .id_result = arg_result_id, + }); + self.args.appendAssumeCapacity(arg_result_id); + } - try self.args.ensureUnusedCapacity(self.gpa, fn_info.param_types.len); - for (fn_info.param_types.get(ip)) |param_ty_index| { - const param_ty = Type.fromInterned(param_ty_index); - if (!param_ty.hasRuntimeBitsIgnoreComptime(mod)) continue; + // TODO: This could probably be done in a better way... + const root_block_id = self.spv.allocId(); - const param_type_id = try self.resolveTypeId(param_ty); - const arg_result_id = self.spv.allocId(); - try self.func.prologue.emit(self.spv.gpa, .OpFunctionParameter, .{ - .id_result_type = param_type_id, - .id_result = arg_result_id, + // The root block of a function declaration should appear before OpVariable instructions, + // so it is generated into the function's prologue. + try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ + .id_result = root_block_id, }); - self.args.appendAssumeCapacity(arg_result_id); - } + self.current_block_label = root_block_id; - // TODO: This could probably be done in a better way... - const root_block_id = self.spv.allocId(); + const main_body = self.air.getMainBody(); + switch (self.control_flow) { + .structured => { + _ = try self.genStructuredBody(.selection, main_body); + // We always expect paths to here to end, but we still need the block + // to act as a dummy merge block. + try self.func.body.emit(self.spv.gpa, .OpUnreachable, {}); + }, + .unstructured => { + try self.genBody(main_body); + }, + } + try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); + // Append the actual code into the functions section. + try self.spv.addFunction(spv_decl_index, self.func); - // The root block of a function declaration should appear before OpVariable instructions, - // so it is generated into the function's prologue. - try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ - .id_result = root_block_id, - }); - self.current_block_label = root_block_id; + const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module)); + try self.spv.debugName(result_id, fqn); - const main_body = self.air.getMainBody(); - switch (self.control_flow) { - .structured => { - _ = try self.genStructuredBody(.selection, main_body); - // We always expect paths to here to end, but we still need the block - // to act as a dummy merge block. - try self.func.body.emit(self.spv.gpa, .OpUnreachable, {}); - }, - .unstructured => { - try self.genBody(main_body); - }, - } - try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); - // Append the actual code into the functions section. - try self.spv.addFunction(spv_decl_index, self.func); + // Temporarily generate a test kernel declaration if this is a test function. + if (self.module.test_functions.contains(self.decl_index)) { + try self.generateTestEntryPoint(fqn, spv_decl_index); + } + }, + .global => { + const maybe_init_val: ?Value = blk: { + if (decl.val.getVariable(mod)) |payload| { + if (payload.is_extern) break :blk null; + break :blk Value.fromInterned(payload.init); + } + break :blk decl.val; + }; + assert(maybe_init_val == null); // TODO - const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module)); - try self.spv.debugName(decl_id, fqn); + const final_storage_class = self.spvStorageClass(decl.@"addrspace"); + assert(final_storage_class != .Generic); // These should be instance globals - // Temporarily generate a test kernel declaration if this is a test function. - if (self.module.test_functions.contains(self.decl_index)) { - try self.generateTestEntryPoint(fqn, spv_decl_index); - } - } else { - const opt_init_val: ?Value = blk: { - if (decl.val.getVariable(mod)) |payload| { - if (payload.is_extern) break :blk null; - break :blk Value.fromInterned(payload.init); - } - break :blk decl.val; - }; + const ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class); - // Generate the actual variable for the global... - const final_storage_class = self.spvStorageClass(decl.@"addrspace"); - const actual_storage_class = blk: { - if (target.os.tag != .vulkan) { - break :blk switch (final_storage_class) { - .Generic => .CrossWorkgroup, - else => final_storage_class, - }; - } - break :blk final_storage_class; - }; + try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpVariable, .{ + .id_result_type = self.typeId(ptr_ty_ref), + .id_result = result_id, + .storage_class = final_storage_class, + }); - const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class); + const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module)); + try self.spv.debugName(result_id, fqn); + try self.spv.declareDeclDeps(spv_decl_index, &.{}); + }, + .invocation_global => { + const maybe_init_val: ?Value = blk: { + if (decl.val.getVariable(mod)) |payload| { + if (payload.is_extern) break :blk null; + break :blk Value.fromInterned(payload.init); + } + break :blk decl.val; + }; - const begin = self.spv.beginGlobal(); - try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{ - .id_result_type = self.typeId(ptr_ty_ref), - .id_result = decl_id, - .storage_class = actual_storage_class, - }); - const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module)); - try self.spv.debugName(decl_id, fqn); + try self.spv.declareDeclDeps(spv_decl_index, &.{}); - if (opt_init_val) |init_val| { - // Currently, initializers for CrossWorkgroup variables is not implemented - // in Mesa. Therefore we generate an initialization kernel instead. - const void_ty_ref = try self.resolveType(Type.void, .direct); + const ptr_ty_ref = try self.ptrType(decl.ty, .Function); - const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ - .return_type = void_ty_ref, - .parameters = &.{}, - } }); + if (maybe_init_val) |init_val| { + // TODO: Combine with resolveAnonDecl? + const void_ty_ref = try self.resolveType(Type.void, .direct); + const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ + .return_type = void_ty_ref, + .parameters = &.{}, + } }); - // Now emit the instructions that initialize the variable. - const initializer_id = self.spv.allocId(); - try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ - .id_result_type = self.typeId(void_ty_ref), - .id_result = initializer_id, - .function_control = .{}, - .function_type = self.typeId(initializer_proto_ty_ref), - }); - const root_block_id = self.spv.allocId(); - try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ - .id_result = root_block_id, - }); - self.current_block_label = root_block_id; + const initializer_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ + .id_result_type = self.typeId(void_ty_ref), + .id_result = initializer_id, + .function_control = .{}, + .function_type = self.typeId(initializer_proto_ty_ref), + }); - const val_id = try self.constant(decl.ty, init_val, .indirect); - try self.func.body.emit(self.spv.gpa, .OpStore, .{ - .pointer = decl_id, - .object = val_id, - }); + const root_block_id = self.spv.allocId(); + try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ + .id_result = root_block_id, + }); + self.current_block_label = root_block_id; - // TODO: We should be able to get rid of this by now... - self.spv.endGlobal(spv_decl_index, begin, decl_id, initializer_id); + const val_id = try self.constant(decl.ty, init_val, .indirect); + try self.func.body.emit(self.spv.gpa, .OpStore, .{ + .pointer = result_id, + .object = val_id, + }); - try self.func.body.emit(self.spv.gpa, .OpReturn, {}); - try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); - try self.spv.addFunction(spv_decl_index, self.func); + try self.func.body.emit(self.spv.gpa, .OpReturn, {}); + try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); + try self.spv.addFunction(spv_decl_index, self.func); - try self.spv.debugNameFmt(initializer_id, "initializer of {s}", .{fqn}); - } else { - self.spv.endGlobal(spv_decl_index, begin, decl_id, null); - try self.spv.declareDeclDeps(spv_decl_index, &.{}); - } + const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module)); + try self.spv.debugNameFmt(initializer_id, "initializer of {s}", .{fqn}); + + try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpExtInst, .{ + .id_result_type = self.typeId(ptr_ty_ref), + .id_result = result_id, + .set = try self.spv.importInstructionSet(.zig), + .instruction = .{ .inst = 0 }, // TODO: Put this definition somewhere... + .id_ref_4 = &.{initializer_id}, + }); + } else { + try self.spv.sections.types_globals_constants.emit(self.spv.gpa, .OpExtInst, .{ + .id_result_type = self.typeId(ptr_ty_ref), + .id_result = result_id, + .set = try self.spv.importInstructionSet(.zig), + .instruction = .{ .inst = 0 }, // TODO: Put this definition somewhere... + .id_ref_4 = &.{}, + }); + } + }, } } @@ -2487,8 +2591,8 @@ const DeclGen = struct { else => unreachable, }; const set_id = switch (target.os.tag) { - .opencl => try self.spv.importInstructionSet(.opencl), - .vulkan => try self.spv.importInstructionSet(.glsl), + .opencl => try self.spv.importInstructionSet(.@"OpenCL.std"), + .vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"), else => unreachable, }; @@ -2662,8 +2766,8 @@ const DeclGen = struct { else => unreachable, }; const set_id = switch (target.os.tag) { - .opencl => try self.spv.importInstructionSet(.opencl), - .vulkan => try self.spv.importInstructionSet(.glsl), + .opencl => try self.spv.importInstructionSet(.@"OpenCL.std"), + .vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"), else => unreachable, }; @@ -2792,8 +2896,9 @@ const DeclGen = struct { ov_id.* = try self.intFromBool(wip_ov.ty_ref, overflowed_id); } - return try self.constructComposite( + return try self.constructStruct( result_ty, + &.{ operand_ty, ov_ty }, &.{ try wip_result.finalize(), try wip_ov.finalize() }, ); } @@ -2885,8 +2990,9 @@ const DeclGen = struct { ov_id.* = try self.intFromBool(wip_ov.ty_ref, overflowed_id); } - return try self.constructComposite( + return try self.constructStruct( result_ty, + &.{ operand_ty, ov_ty }, &.{ try wip_result.finalize(), try wip_ov.finalize() }, ); } @@ -3201,35 +3307,76 @@ const DeclGen = struct { else try self.convertToDirect(Type.bool, rhs_id); - const valid_cmp_id = try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id); if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) { - return valid_cmp_id; + return try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id); } - // TODO: Should we short circuit here? It shouldn't affect correctness, but - // perhaps it will generate more efficient code. + // a = lhs_valid + // b = rhs_valid + // c = lhs_pl == rhs_pl + // + // For op == .eq we have: + // a == b && a -> c + // = a == b && (!a || c) + // + // For op == .neq we have + // a == b && a -> c + // = !(a == b && a -> c) + // = a != b || !(a -> c + // = a != b || !(!a || c) + // = a != b || a && !c const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0); const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0); - const pl_cmp_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id); - - // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl - // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl - - const result_id = self.spv.allocId(); - const args = .{ - .id_result_type = self.typeId(bool_ty_ref), - .id_result = result_id, - .operand_1 = valid_cmp_id, - .operand_2 = pl_cmp_id, - }; switch (op) { - .eq => try self.func.body.emit(self.spv.gpa, .OpLogicalAnd, args), - .neq => try self.func.body.emit(self.spv.gpa, .OpLogicalOr, args), + .eq => { + const valid_eq_id = try self.cmp(.eq, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id); + const pl_eq_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id); + const lhs_not_valid_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalNot, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = lhs_not_valid_id, + .operand = lhs_valid_id, + }); + const impl_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalOr, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = impl_id, + .operand_1 = lhs_not_valid_id, + .operand_2 = pl_eq_id, + }); + const result_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalAnd, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = result_id, + .operand_1 = valid_eq_id, + .operand_2 = impl_id, + }); + return result_id; + }, + .neq => { + const valid_neq_id = try self.cmp(.neq, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id); + const pl_neq_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id); + + const impl_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalAnd, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = impl_id, + .operand_1 = lhs_valid_id, + .operand_2 = pl_neq_id, + }); + const result_id = self.spv.allocId(); + try self.func.body.emit(self.spv.gpa, .OpLogicalOr, .{ + .id_result_type = self.typeId(bool_ty_ref), + .id_result = result_id, + .operand_1 = valid_neq_id, + .operand_2 = impl_id, + }); + return result_id; + }, else => unreachable, } - return result_id; }, .Vector => { var wip = try self.elementWise(result_ty, true); @@ -3588,7 +3735,11 @@ const DeclGen = struct { // Convert the pointer-to-array to a pointer to the first element. try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0}); - return try self.constructComposite(slice_ty, &.{ elem_ptr_id, len_id }); + return try self.constructStruct( + slice_ty, + &.{ elem_ptr_ty, Type.usize }, + &.{ elem_ptr_id, len_id }, + ); } fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { @@ -3596,11 +3747,16 @@ const DeclGen = struct { const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data; const ptr_id = try self.resolve(bin_op.lhs); const len_id = try self.resolve(bin_op.rhs); + const ptr_ty = self.typeOf(bin_op.lhs); const slice_ty = self.typeOfIndex(inst); // Note: Types should not need to be converted to direct, these types // dont need to be converted. - return try self.constructComposite(slice_ty, &.{ ptr_id, len_id }); + return try self.constructStruct( + slice_ty, + &.{ ptr_ty, Type.usize }, + &.{ ptr_id, len_id }, + ); } fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { @@ -3618,6 +3774,8 @@ const DeclGen = struct { unreachable; // TODO } + const types = try self.gpa.alloc(Type, elements.len); + defer self.gpa.free(types); const constituents = try self.gpa.alloc(IdRef, elements.len); defer self.gpa.free(constituents); var index: usize = 0; @@ -3629,6 +3787,7 @@ const DeclGen = struct { assert(Type.fromInterned(field_ty).hasRuntimeBits(mod)); const id = try self.resolve(element); + types[index] = Type.fromInterned(field_ty); constituents[index] = try self.convertToIndirect(Type.fromInterned(field_ty), id); index += 1; } @@ -3643,6 +3802,7 @@ const DeclGen = struct { assert(field_ty.hasRuntimeBitsIgnoreComptime(mod)); const id = try self.resolve(element); + types[index] = field_ty; constituents[index] = try self.convertToIndirect(field_ty, id); index += 1; } @@ -3650,7 +3810,11 @@ const DeclGen = struct { else => unreachable, } - return try self.constructComposite(result_ty, constituents[0..index]); + return try self.constructStruct( + result_ty, + types[0..index], + constituents[0..index], + ); }, .Vector => { const n_elems = result_ty.vectorLen(mod); @@ -3662,7 +3826,7 @@ const DeclGen = struct { elem_ids[i] = try self.convertToIndirect(result_ty.childType(mod), id); } - return try self.constructComposite(result_ty, elem_ids); + return try self.constructVector(result_ty, elem_ids); }, .Array => { const array_info = result_ty.arrayInfo(mod); @@ -3679,7 +3843,7 @@ const DeclGen = struct { elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect); } - return try self.constructComposite(result_ty, elem_ids); + return try self.constructArray(result_ty, elem_ids); }, else => unreachable, } @@ -4792,7 +4956,11 @@ const DeclGen = struct { members[eu_layout.errorFieldIndex()] = operand_id; members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref); - return try self.constructComposite(err_union_ty, &members); + var types: [2]Type = undefined; + types[eu_layout.errorFieldIndex()] = Type.anyerror; + types[eu_layout.payloadFieldIndex()] = payload_ty; + + return try self.constructStruct(err_union_ty, &types, &members); } fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef { @@ -4811,7 +4979,11 @@ const DeclGen = struct { members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0); members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id); - return try self.constructComposite(err_union_ty, &members); + var types: [2]Type = undefined; + types[eu_layout.errorFieldIndex()] = Type.anyerror; + types[eu_layout.payloadFieldIndex()] = payload_ty; + + return try self.constructStruct(err_union_ty, &types, &members); } fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, is_pointer: bool, pred: enum { is_null, is_non_null }) !?IdRef { @@ -4978,7 +5150,8 @@ const DeclGen = struct { const payload_id = try self.convertToIndirect(payload_ty, operand_id); const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) }; - return try self.constructComposite(optional_ty, &members); + const types = [_]Type{ payload_ty, Type.bool }; + return try self.constructStruct(optional_ty, &types, &members); } fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void { @@ -5058,7 +5231,7 @@ const DeclGen = struct { const case_body = self.air.extra[case.end + items.len ..][0..case.data.body_len]; extra_index = case.end + case.data.items_len + case_body.len; - const label = IdRef{ .id = @intCast(first_case_label.id + case_i) }; + const label: IdRef = @enumFromInt(@intFromEnum(first_case_label) + case_i); for (items) |item| { const value = (try self.air.value(item, mod)) orelse unreachable; @@ -5072,7 +5245,7 @@ const DeclGen = struct { else => unreachable, }; const int_lit: spec.LiteralContextDependentNumber = switch (cond_words) { - 1 => .{ .uint32 = @as(u32, @intCast(int_val)) }, + 1 => .{ .uint32 = @intCast(int_val) }, 2 => .{ .uint64 = int_val }, else => unreachable, }; @@ -5097,7 +5270,7 @@ const DeclGen = struct { const case_body: []const Air.Inst.Index = @ptrCast(self.air.extra[case.end + items.len ..][0..case.data.body_len]); extra_index = case.end + case.data.items_len + case_body.len; - const label = IdResult{ .id = @intCast(first_case_label.id + case_i) }; + const label: IdResult = @enumFromInt(@intFromEnum(first_case_label) + case_i); try self.beginSpvBlock(label); @@ -5327,9 +5500,9 @@ const DeclGen = struct { const result_id = self.spv.allocId(); const callee_id = try self.resolve(pl_op.operand); + comptime assert(zig_call_abi_ver == 3); const params = try self.gpa.alloc(spec.IdRef, args.len); defer self.gpa.free(params); - var n_params: usize = 0; for (args) |arg| { // Note: resolve() might emit instructions, so we need to call it diff --git a/src/codegen/spirv/Assembler.zig b/src/codegen/spirv/Assembler.zig index 7cecd7ee38f2..2c97212d5a96 100644 --- a/src/codegen/spirv/Assembler.zig +++ b/src/codegen/spirv/Assembler.zig @@ -194,6 +194,11 @@ inst: struct { /// This map maps results to their tracked values. value_map: AsmValueMap = .{}, +/// This set is used to quickly transform from an opcode name to the +/// index in its instruction set. The index of the key is the +/// index in `spec.InstructionSet.core.instructions()`. +instruction_map: std.StringArrayHashMapUnmanaged(void) = .{}, + /// Free the resources owned by this assembler. pub fn deinit(self: *Assembler) void { for (self.errors.items) |err| { @@ -204,9 +209,20 @@ pub fn deinit(self: *Assembler) void { self.inst.operands.deinit(self.gpa); self.inst.string_bytes.deinit(self.gpa); self.value_map.deinit(self.gpa); + self.instruction_map.deinit(self.gpa); } pub fn assemble(self: *Assembler) Error!void { + // Populate the opcode map if it isn't already + if (self.instruction_map.count() == 0) { + const instructions = spec.InstructionSet.core.instructions(); + try self.instruction_map.ensureUnusedCapacity(self.gpa, @intCast(instructions.len)); + for (spec.InstructionSet.core.instructions(), 0..) |inst, i| { + const entry = try self.instruction_map.getOrPut(self.gpa, inst.name); + assert(entry.index == i); + } + } + try self.tokenize(); while (!self.testToken(.eof)) { try self.parseInstruction(); @@ -475,12 +491,14 @@ fn parseInstruction(self: *Assembler) !void { } const opcode_text = self.tokenText(opcode_tok); - @setEvalBranchQuota(10000); - self.inst.opcode = std.meta.stringToEnum(Opcode, opcode_text) orelse { + const index = self.instruction_map.getIndex(opcode_text) orelse { return self.fail(opcode_tok.start, "invalid opcode '{s}'", .{opcode_text}); }; - const expected_operands = self.inst.opcode.operands(); + const inst = spec.InstructionSet.core.instructions()[index]; + self.inst.opcode = @enumFromInt(inst.opcode); + + const expected_operands = inst.operands; // This is a loop because the result-id is not always the first operand. const requires_lhs_result = for (expected_operands) |op| { if (op.kind == .IdResult) break true; diff --git a/src/codegen/spirv/Cache.zig b/src/codegen/spirv/Cache.zig index 93921204dbf0..e8460e1d79f4 100644 --- a/src/codegen/spirv/Cache.zig +++ b/src/codegen/spirv/Cache.zig @@ -134,7 +134,10 @@ const Tag = enum { /// data is (bool) type bool_false, - const SimpleType = enum { void, bool }; + const SimpleType = enum { + void, + bool, + }; const VectorType = Key.VectorType; const ArrayType = Key.ArrayType; @@ -287,11 +290,12 @@ pub const Key = union(enum) { pub const PointerType = struct { storage_class: StorageClass, child_type: Ref, + /// Ref to a .fwd_ptr_type. fwd: Ref, // TODO: Decorations: // - Alignment - // - ArrayStride, - // - MaxByteOffset, + // - ArrayStride + // - MaxByteOffset }; pub const ForwardPointerType = struct { @@ -728,6 +732,9 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref { // }, .ptr_type => |ptr| Item{ .tag = .type_ptr_simple, + // For this variant we need to steal the ID of the forward-declaration, instead + // of allocating one manually. This will make sure that we get a single result-id + // any possibly forward declared pointer type. .result_id = self.resultId(ptr.fwd), .data = try self.addExtra(spv, Tag.SimplePointerType{ .storage_class = ptr.storage_class, @@ -896,24 +903,6 @@ pub fn lookup(self: *const Self, ref: Ref) Key { }, }; }, - // .type_ptr_generic => .{ - // .ptr_type = .{ - // .storage_class = .Generic, - // .child_type = @enumFromInt(data), - // }, - // }, - // .type_ptr_crosswgp => .{ - // .ptr_type = .{ - // .storage_class = .CrossWorkgroup, - // .child_type = @enumFromInt(data), - // }, - // }, - // .type_ptr_function => .{ - // .ptr_type = .{ - // .storage_class = .Function, - // .child_type = @enumFromInt(data), - // }, - // }, .type_ptr_simple => { const payload = self.extraData(Tag.SimplePointerType, data); return .{ diff --git a/src/codegen/spirv/Module.zig b/src/codegen/spirv/Module.zig index 61ef36162f0f..b65056689000 100644 --- a/src/codegen/spirv/Module.zig +++ b/src/codegen/spirv/Module.zig @@ -72,9 +72,20 @@ pub const Decl = struct { /// Index to refer to a Decl by. pub const Index = enum(u32) { _ }; - /// The result-id to be used for this declaration. This is the final result-id - /// of the decl, which may be an OpFunction, OpVariable, or the result of a sequence - /// of OpSpecConstantOp operations. + /// Useful to tell what kind of decl this is, and hold the result-id or field index + /// to be used for this decl. + pub const Kind = enum { + func, + global, + invocation_global, + }; + + /// See comment on Kind + kind: Kind, + /// The result-id associated to this decl. The specific meaning of this depends on `kind`: + /// - For `func`, this is the result-id of the associated OpFunction instruction. + /// - For `global`, this is the result-id of the associated OpVariable instruction. + /// - For `invocation_global`, this is the result-id of the associated InvocationGlobal instruction. result_id: IdRef, /// The offset of the first dependency of this decl in the `decl_deps` array. begin_dep: u32, @@ -82,20 +93,6 @@ pub const Decl = struct { end_dep: u32, }; -/// Globals must be kept in order: operations involving globals must be ordered -/// so that the global declaration precedes any usage. -pub const Global = struct { - /// This is the result-id of the OpVariable instruction that declares the global. - result_id: IdRef, - /// The offset into `self.globals.section` of the first instruction of this global - /// declaration. - begin_inst: u32, - /// The past-end offset into `self.flobals.section`. - end_inst: u32, - /// The result-id of the function that initializes this value. - initializer_id: ?IdRef, -}; - /// This models a kernel entry point. pub const EntryPoint = struct { /// The declaration that should be exported. @@ -165,18 +162,8 @@ decl_deps: std.ArrayListUnmanaged(Decl.Index) = .{}, /// The list of entry points that should be exported from this module. entry_points: std.ArrayListUnmanaged(EntryPoint) = .{}, -/// The fields in this structure help to maintain the required order for global variables. -globals: struct { - /// Set of globals, referred to by Decl.Index. - globals: std.AutoArrayHashMapUnmanaged(Decl.Index, Global) = .{}, - /// This pseudo-section contains the initialization code for all the globals. Instructions from - /// here are reordered when flushing the module. Its contents should be part of the - /// `types_globals_constants` SPIR-V section when the module is emitted. - section: Section = .{}, -} = .{}, - /// The list of extended instruction sets that should be imported. -extended_instruction_set: std.AutoHashMapUnmanaged(ExtendedInstructionSet, IdRef) = .{}, +extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, IdRef) = .{}, pub fn init(gpa: Allocator) Module { return .{ @@ -205,9 +192,6 @@ pub fn deinit(self: *Module) void { self.entry_points.deinit(self.gpa); - self.globals.globals.deinit(self.gpa); - self.globals.section.deinit(self.gpa); - self.extended_instruction_set.deinit(self.gpa); self.* = undefined; @@ -215,12 +199,12 @@ pub fn deinit(self: *Module) void { pub fn allocId(self: *Module) spec.IdResult { defer self.next_result_id += 1; - return .{ .id = self.next_result_id }; + return @enumFromInt(self.next_result_id); } pub fn allocIds(self: *Module, n: u32) spec.IdResult { defer self.next_result_id += n; - return .{ .id = self.next_result_id }; + return @enumFromInt(self.next_result_id); } pub fn idBound(self: Module) Word { @@ -243,46 +227,6 @@ pub fn resolveString(self: *Module, str: []const u8) !CacheString { return try self.cache.addString(self, str); } -fn orderGlobalsInto( - self: *Module, - decl_index: Decl.Index, - section: *Section, - seen: *std.DynamicBitSetUnmanaged, -) !void { - const decl = self.declPtr(decl_index); - const deps = self.decl_deps.items[decl.begin_dep..decl.end_dep]; - const global = self.globalPtr(decl_index).?; - const insts = self.globals.section.instructions.items[global.begin_inst..global.end_inst]; - - seen.set(@intFromEnum(decl_index)); - - for (deps) |dep| { - if (!seen.isSet(@intFromEnum(dep))) { - try self.orderGlobalsInto(dep, section, seen); - } - } - - try section.instructions.appendSlice(self.gpa, insts); -} - -fn orderGlobals(self: *Module) !Section { - const globals = self.globals.globals.keys(); - - var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len); - defer seen.deinit(self.gpa); - - var ordered_globals = Section{}; - errdefer ordered_globals.deinit(self.gpa); - - for (globals) |decl_index| { - if (!seen.isSet(@intFromEnum(decl_index))) { - try self.orderGlobalsInto(decl_index, &ordered_globals, &seen); - } - } - - return ordered_globals; -} - fn addEntryPointDeps( self: *Module, decl_index: Decl.Index, @@ -298,8 +242,8 @@ fn addEntryPointDeps( seen.set(@intFromEnum(decl_index)); - if (self.globalPtr(decl_index)) |global| { - try interface.append(global.result_id); + if (decl.kind == .global) { + try interface.append(decl.result_id); } for (deps) |dep| { @@ -335,81 +279,9 @@ fn entryPoints(self: *Module) !Section { return entry_points; } -/// Generate a function that calls all initialization functions, -/// in unspecified order (an order should not be required here). -/// It generated as follows: -/// %init = OpFunction %void None -/// foreach %initializer: -/// OpFunctionCall %initializer -/// OpReturn -/// OpFunctionEnd -fn initializer(self: *Module, entry_points: *Section) !Section { - var section = Section{}; - errdefer section.deinit(self.gpa); - - // const void_ty_ref = try self.resolveType(Type.void, .direct); - const void_ty_ref = try self.resolve(.void_type); - const void_ty_id = self.resultId(void_ty_ref); - const init_proto_ty_ref = try self.resolve(.{ .function_type = .{ - .return_type = void_ty_ref, - .parameters = &.{}, - } }); - - const init_id = self.allocId(); - try section.emit(self.gpa, .OpFunction, .{ - .id_result_type = void_ty_id, - .id_result = init_id, - .function_control = .{}, - .function_type = self.resultId(init_proto_ty_ref), - }); - try section.emit(self.gpa, .OpLabel, .{ - .id_result = self.allocId(), - }); - - var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len); - defer seen.deinit(self.gpa); - - var interface = std.ArrayList(IdRef).init(self.gpa); - defer interface.deinit(); - - for (self.globals.globals.keys(), self.globals.globals.values()) |decl_index, global| { - try self.addEntryPointDeps(decl_index, &seen, &interface); - if (global.initializer_id) |initializer_id| { - try section.emit(self.gpa, .OpFunctionCall, .{ - .id_result_type = void_ty_id, - .id_result = self.allocId(), - .function = initializer_id, - }); - } - } - - try section.emit(self.gpa, .OpReturn, {}); - try section.emit(self.gpa, .OpFunctionEnd, {}); - - try entry_points.emit(self.gpa, .OpEntryPoint, .{ - // TODO: Rusticl does not support this because its poorly defined. - // Do we need to generate a workaround here? - .execution_model = .Kernel, - .entry_point = init_id, - .name = "zig global initializer", - .interface = interface.items, - }); - - try self.sections.execution_modes.emit(self.gpa, .OpExecutionMode, .{ - .entry_point = init_id, - .mode = .Initializer, - }); - - return section; -} - -/// Emit this module as a spir-v binary. -pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void { +pub fn finalize(self: *Module, a: Allocator, target: std.Target) ![]Word { // See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction" - - // TODO: Perform topological sort on the globals. - var globals = try self.orderGlobals(); - defer globals.deinit(self.gpa); + // TODO: Audit calls to allocId() in this function to make it idempotent. var entry_points = try self.entryPoints(); defer entry_points.deinit(self.gpa); @@ -417,13 +289,6 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void { var types_constants = try self.cache.materialize(self); defer types_constants.deinit(self.gpa); - // // TODO: Pass global variables as function parameters - // var init_func = if (target.os.tag != .vulkan) - // try self.initializer(&entry_points) - // else - // Section{}; - // defer init_func.deinit(self.gpa); - const header = [_]Word{ spec.magic_number, // TODO: From cpu features @@ -436,7 +301,7 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void { else => 4, }, }), - 0, // TODO: Register Zig compiler magic number. + spec.zig_generator_id, self.idBound(), 0, // Schema (currently reserved for future use) }; @@ -468,30 +333,23 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void { self.sections.annotations.toWords(), types_constants.toWords(), self.sections.types_globals_constants.toWords(), - globals.toWords(), self.sections.functions.toWords(), }; - if (builtin.zig_backend == .stage2_x86_64) { - for (buffers) |buf| { - try file.writeAll(std.mem.sliceAsBytes(buf)); - } - } else { - // miscompiles with x86_64 backend - var iovc_buffers: [buffers.len]std.os.iovec_const = undefined; - var file_size: u64 = 0; - for (&iovc_buffers, 0..) |*iovc, i| { - // Note, since spir-v supports both little and big endian we can ignore byte order here and - // just treat the words as a sequence of bytes. - const bytes = std.mem.sliceAsBytes(buffers[i]); - iovc.* = .{ .iov_base = bytes.ptr, .iov_len = bytes.len }; - file_size += bytes.len; - } - - try file.seekTo(0); - try file.setEndPos(file_size); - try file.pwritevAll(&iovc_buffers, 0); + var total_result_size: usize = 0; + for (buffers) |buffer| { + total_result_size += buffer.len; + } + const result = try a.alloc(Word, total_result_size); + errdefer a.free(result); + + var offset: usize = 0; + for (buffers) |buffer| { + @memcpy(result[offset..][0..buffer.len], buffer); + offset += buffer.len; } + + return result; } /// Merge the sections making up a function declaration into this module. @@ -501,23 +359,17 @@ pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void { try self.declareDeclDeps(decl_index, func.decl_deps.keys()); } -pub const ExtendedInstructionSet = enum { - glsl, - opencl, -}; - /// Imports or returns the existing id of an extended instruction set -pub fn importInstructionSet(self: *Module, set: ExtendedInstructionSet) !IdRef { +pub fn importInstructionSet(self: *Module, set: spec.InstructionSet) !IdRef { + assert(set != .core); + const gop = try self.extended_instruction_set.getOrPut(self.gpa, set); if (gop.found_existing) return gop.value_ptr.*; const result_id = self.allocId(); try self.sections.extended_instruction_set.emit(self.gpa, .OpExtInstImport, .{ .id_result = result_id, - .name = switch (set) { - .glsl => "GLSL.std.450", - .opencl => "OpenCL.std", - }, + .name = @tagName(set), }); gop.value_ptr.* = result_id; @@ -631,40 +483,21 @@ pub fn decorateMember( }); } -pub const DeclKind = enum { - func, - global, -}; - -pub fn allocDecl(self: *Module, kind: DeclKind) !Decl.Index { +pub fn allocDecl(self: *Module, kind: Decl.Kind) !Decl.Index { try self.decls.append(self.gpa, .{ + .kind = kind, .result_id = self.allocId(), .begin_dep = undefined, .end_dep = undefined, }); - const index = @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1)))); - switch (kind) { - .func => {}, - // If the decl represents a global, also allocate a global node. - .global => try self.globals.globals.putNoClobber(self.gpa, index, .{ - .result_id = undefined, - .begin_inst = undefined, - .end_inst = undefined, - .initializer_id = undefined, - }), - } - return index; + return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1)))); } pub fn declPtr(self: *Module, index: Decl.Index) *Decl { return &self.decls.items[@intFromEnum(index)]; } -pub fn globalPtr(self: *Module, index: Decl.Index) ?*Global { - return self.globals.globals.getPtr(index); -} - /// Declare ALL dependencies for a decl. pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl.Index) !void { const begin_dep = @as(u32, @intCast(self.decl_deps.items.len)); @@ -676,26 +509,9 @@ pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl decl.end_dep = end_dep; } -pub fn beginGlobal(self: *Module) u32 { - return @as(u32, @intCast(self.globals.section.instructions.items.len)); -} - -pub fn endGlobal( - self: *Module, - global_index: Decl.Index, - begin_inst: u32, - result_id: IdRef, - initializer_id: ?IdRef, -) void { - const global = self.globalPtr(global_index).?; - global.* = .{ - .result_id = result_id, - .begin_inst = begin_inst, - .end_inst = @intCast(self.globals.section.instructions.items.len), - .initializer_id = initializer_id, - }; -} - +/// Declare a SPIR-V function as an entry point. This causes an extra wrapper +/// function to be generated, which is then exported as the real entry point. The purpose of this +/// wrapper is to allocate and initialize the structure holding the instance globals. pub fn declareEntryPoint( self: *Module, decl_index: Decl.Index, diff --git a/src/codegen/spirv/Section.zig b/src/codegen/spirv/Section.zig index 002dad2510a3..d3b84dc27d2a 100644 --- a/src/codegen/spirv/Section.zig +++ b/src/codegen/spirv/Section.zig @@ -53,6 +53,17 @@ pub fn emitRaw( section.writeWord((@as(Word, @intCast(word_count << 16))) | @intFromEnum(opcode)); } +/// Write an entire instruction, including all operands +pub fn emitRawInstruction( + section: *Section, + allocator: Allocator, + opcode: Opcode, + operands: []const Word, +) !void { + try section.emitRaw(allocator, opcode, operands.len); + section.writeWords(operands); +} + pub fn emit( section: *Section, allocator: Allocator, @@ -123,7 +134,7 @@ fn writeOperands(section: *Section, comptime Operands: type, operands: Operands) pub fn writeOperand(section: *Section, comptime Operand: type, operand: Operand) void { switch (Operand) { - spec.IdResult => section.writeWord(operand.id), + spec.IdResult => section.writeWord(@intFromEnum(operand)), spec.LiteralInteger => section.writeWord(operand), @@ -138,9 +149,9 @@ pub fn writeOperand(section: *Section, comptime Operand: type, operand: Operand) // instruction in which it is used. spec.LiteralSpecConstantOpInteger => section.writeWord(@intFromEnum(operand.opcode)), - spec.PairLiteralIntegerIdRef => section.writeWords(&.{ operand.value, operand.label.id }), - spec.PairIdRefLiteralInteger => section.writeWords(&.{ operand.target.id, operand.member }), - spec.PairIdRefIdRef => section.writeWords(&.{ operand[0].id, operand[1].id }), + spec.PairLiteralIntegerIdRef => section.writeWords(&.{ operand.value, @enumFromInt(operand.label) }), + spec.PairIdRefLiteralInteger => section.writeWords(&.{ @intFromEnum(operand.target), operand.member }), + spec.PairIdRefIdRef => section.writeWords(&.{ @intFromEnum(operand[0]), @intFromEnum(operand[1]) }), else => switch (@typeInfo(Operand)) { .Enum => section.writeWord(@intFromEnum(operand)), @@ -338,8 +349,8 @@ test "SPIR-V Section emit() - simple" { defer section.deinit(std.testing.allocator); try section.emit(std.testing.allocator, .OpUndef, .{ - .id_result_type = .{ .id = 0 }, - .id_result = .{ .id = 1 }, + .id_result_type = @enumFromInt(0), + .id_result = @enumFromInt(1), }); try testing.expectEqualSlices(Word, &.{ @@ -356,7 +367,7 @@ test "SPIR-V Section emit() - string" { try section.emit(std.testing.allocator, .OpSource, .{ .source_language = .Unknown, .version = 123, - .file = .{ .id = 456 }, + .file = @enumFromInt(256), .source = "pub fn main() void {}", }); @@ -381,8 +392,8 @@ test "SPIR-V Section emit() - extended mask" { defer section.deinit(std.testing.allocator); try section.emit(std.testing.allocator, .OpLoopMerge, .{ - .merge_block = .{ .id = 10 }, - .continue_target = .{ .id = 20 }, + .merge_block = @enumFromInt(10), + .continue_target = @enumFromInt(20), .loop_control = .{ .Unroll = true, .DependencyLength = .{ @@ -405,7 +416,7 @@ test "SPIR-V Section emit() - extended union" { defer section.deinit(std.testing.allocator); try section.emit(std.testing.allocator, .OpExecutionMode, .{ - .entry_point = .{ .id = 888 }, + .entry_point = @enumFromInt(888), .mode = .{ .LocalSize = .{ .x_size = 4, .y_size = 8, .z_size = 16 }, }, diff --git a/src/codegen/spirv/extinst.zig.grammar.json b/src/codegen/spirv/extinst.zig.grammar.json new file mode 100644 index 000000000000..70c290097e38 --- /dev/null +++ b/src/codegen/spirv/extinst.zig.grammar.json @@ -0,0 +1,13 @@ +{ + "version": 0, + "revision": 0, + "instructions": [ + { + "opname": "InvocationGlobal", + "opcode": 0, + "operands": [ + { "kind": "IdRef", "name": "initializer function" } + ] + } + ] +} diff --git a/src/codegen/spirv/spec.zig b/src/codegen/spirv/spec.zig index 7cd4bbbd1bbb..970f5bfe7f97 100644 --- a/src/codegen/spirv/spec.zig +++ b/src/codegen/spirv/spec.zig @@ -1,5 +1,7 @@ //! This file is auto-generated by tools/gen_spirv_spec.zig. +const std = @import("std"); + pub const Version = packed struct(Word) { padding: u8 = 0, minor: u8, @@ -12,8 +14,21 @@ pub const Version = packed struct(Word) { }; pub const Word = u32; -pub const IdResult = struct { - id: Word, +pub const IdResult = enum(Word) { + none, + _, + + pub fn format( + self: IdResult, + comptime _: []const u8, + _: std.fmt.FormatOptions, + writer: anytype, + ) @TypeOf(writer).Error!void { + switch (self) { + .none => try writer.writeAll("(none)"), + else => try writer.print("%{}", .{@intFromEnum(self)}), + } + } }; pub const IdResultType = IdResult; pub const IdRef = IdResult; @@ -22,6 +37,7 @@ pub const IdMemorySemantics = IdRef; pub const IdScope = IdRef; pub const LiteralInteger = Word; +pub const LiteralFloat = Word; pub const LiteralString = []const u8; pub const LiteralContextDependentNumber = union(enum) { int32: i32, @@ -62,6 +78,13 @@ pub const Enumerant = struct { parameters: []const OperandKind, }; +pub const Instruction = struct { + name: []const u8, + opcode: Word, + operands: []const Operand, +}; + +pub const zig_generator_id: Word = 41; pub const version = Version{ .major = 1, .minor = 6, .patch = 1 }; pub const magic_number: Word = 0x07230203; @@ -92,7 +115,9 @@ pub const Class = enum { NonUniform, Reserved, }; + pub const OperandKind = enum { + Opcode, ImageOperands, FPFastMathMode, SelectionControl, @@ -103,6 +128,7 @@ pub const OperandKind = enum { KernelProfilingInfo, RayFlags, FragmentShadingRate, + RawAccessChainOperands, SourceLanguage, ExecutionModel, AddressingModel, @@ -122,6 +148,7 @@ pub const OperandKind = enum { OverflowModes, LinkageType, AccessQualifier, + HostAccessQualifier, FunctionParameterAttribute, Decoration, BuiltIn, @@ -133,6 +160,13 @@ pub const OperandKind = enum { RayQueryCommittedIntersectionType, RayQueryCandidateIntersectionType, PackedVectorFormat, + CooperativeMatrixOperands, + CooperativeMatrixLayout, + CooperativeMatrixUse, + InitializationModeQualifier, + LoadCacheControl, + StoreCacheControl, + NamedMaximumNumberOfRegisters, IdResultType, IdResult, IdMemorySemantics, @@ -140,15 +174,36 @@ pub const OperandKind = enum { IdRef, LiteralInteger, LiteralString, + LiteralFloat, LiteralContextDependentNumber, LiteralExtInstInteger, LiteralSpecConstantOpInteger, PairLiteralIntegerIdRef, PairIdRefLiteralInteger, PairIdRefIdRef, + @"OpenCL.DebugInfo.100.DebugInfoFlags", + @"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding", + @"OpenCL.DebugInfo.100.DebugCompositeType", + @"OpenCL.DebugInfo.100.DebugTypeQualifier", + @"OpenCL.DebugInfo.100.DebugOperation", + @"OpenCL.DebugInfo.100.DebugImportedEntity", + @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags", + @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags", + @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding", + @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType", + @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier", + @"NonSemantic.Shader.DebugInfo.100.DebugOperation", + @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity", + @"NonSemantic.ClspvReflection.6.KernelPropertyFlags", + @"DebugInfo.DebugInfoFlags", + @"DebugInfo.DebugBaseTypeAttributeEncoding", + @"DebugInfo.DebugCompositeType", + @"DebugInfo.DebugTypeQualifier", + @"DebugInfo.DebugOperation", pub fn category(self: OperandKind) OperandCategory { return switch (self) { + .Opcode => .literal, .ImageOperands => .bit_enum, .FPFastMathMode => .bit_enum, .SelectionControl => .bit_enum, @@ -159,6 +214,7 @@ pub const OperandKind = enum { .KernelProfilingInfo => .bit_enum, .RayFlags => .bit_enum, .FragmentShadingRate => .bit_enum, + .RawAccessChainOperands => .bit_enum, .SourceLanguage => .value_enum, .ExecutionModel => .value_enum, .AddressingModel => .value_enum, @@ -178,6 +234,7 @@ pub const OperandKind = enum { .OverflowModes => .value_enum, .LinkageType => .value_enum, .AccessQualifier => .value_enum, + .HostAccessQualifier => .value_enum, .FunctionParameterAttribute => .value_enum, .Decoration => .value_enum, .BuiltIn => .value_enum, @@ -189,6 +246,13 @@ pub const OperandKind = enum { .RayQueryCommittedIntersectionType => .value_enum, .RayQueryCandidateIntersectionType => .value_enum, .PackedVectorFormat => .value_enum, + .CooperativeMatrixOperands => .bit_enum, + .CooperativeMatrixLayout => .value_enum, + .CooperativeMatrixUse => .value_enum, + .InitializationModeQualifier => .value_enum, + .LoadCacheControl => .value_enum, + .StoreCacheControl => .value_enum, + .NamedMaximumNumberOfRegisters => .value_enum, .IdResultType => .id, .IdResult => .id, .IdMemorySemantics => .id, @@ -196,16 +260,37 @@ pub const OperandKind = enum { .IdRef => .id, .LiteralInteger => .literal, .LiteralString => .literal, + .LiteralFloat => .literal, .LiteralContextDependentNumber => .literal, .LiteralExtInstInteger => .literal, .LiteralSpecConstantOpInteger => .literal, .PairLiteralIntegerIdRef => .composite, .PairIdRefLiteralInteger => .composite, .PairIdRefIdRef => .composite, + .@"OpenCL.DebugInfo.100.DebugInfoFlags" => .bit_enum, + .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" => .value_enum, + .@"OpenCL.DebugInfo.100.DebugCompositeType" => .value_enum, + .@"OpenCL.DebugInfo.100.DebugTypeQualifier" => .value_enum, + .@"OpenCL.DebugInfo.100.DebugOperation" => .value_enum, + .@"OpenCL.DebugInfo.100.DebugImportedEntity" => .value_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" => .bit_enum, + .@"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" => .bit_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" => .value_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" => .value_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" => .value_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugOperation" => .value_enum, + .@"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" => .value_enum, + .@"NonSemantic.ClspvReflection.6.KernelPropertyFlags" => .bit_enum, + .@"DebugInfo.DebugInfoFlags" => .bit_enum, + .@"DebugInfo.DebugBaseTypeAttributeEncoding" => .value_enum, + .@"DebugInfo.DebugCompositeType" => .value_enum, + .@"DebugInfo.DebugTypeQualifier" => .value_enum, + .@"DebugInfo.DebugOperation" => .value_enum, }; } pub fn enumerants(self: OperandKind) []const Enumerant { return switch (self) { + .Opcode => unreachable, .ImageOperands => &[_]Enumerant{ .{ .name = "Bias", .value = 0x0001, .parameters = &[_]OperandKind{.IdRef} }, .{ .name = "Lod", .value = 0x0002, .parameters = &[_]OperandKind{.IdRef} }, @@ -234,8 +319,11 @@ pub const OperandKind = enum { .{ .name = "NSZ", .value = 0x0004, .parameters = &[_]OperandKind{} }, .{ .name = "AllowRecip", .value = 0x0008, .parameters = &[_]OperandKind{} }, .{ .name = "Fast", .value = 0x0010, .parameters = &[_]OperandKind{} }, + .{ .name = "AllowContract", .value = 0x10000, .parameters = &[_]OperandKind{} }, .{ .name = "AllowContractFastINTEL", .value = 0x10000, .parameters = &[_]OperandKind{} }, + .{ .name = "AllowReassoc", .value = 0x20000, .parameters = &[_]OperandKind{} }, .{ .name = "AllowReassocINTEL", .value = 0x20000, .parameters = &[_]OperandKind{} }, + .{ .name = "AllowTransform", .value = 0x40000, .parameters = &[_]OperandKind{} }, }, .SelectionControl => &[_]Enumerant{ .{ .name = "Flatten", .value = 0x0001, .parameters = &[_]OperandKind{} }, @@ -258,7 +346,9 @@ pub const OperandKind = enum { .{ .name = "LoopCoalesceINTEL", .value = 0x100000, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "MaxInterleavingINTEL", .value = 0x200000, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "SpeculatedIterationsINTEL", .value = 0x400000, .parameters = &[_]OperandKind{.LiteralInteger} }, - .{ .name = "NoFusionINTEL", .value = 0x800000, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "NoFusionINTEL", .value = 0x800000, .parameters = &[_]OperandKind{} }, + .{ .name = "LoopCountINTEL", .value = 0x1000000, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MaxReinvocationDelayINTEL", .value = 0x2000000, .parameters = &[_]OperandKind{.LiteralInteger} }, }, .FunctionControl => &[_]Enumerant{ .{ .name = "Inline", .value = 0x0001, .parameters = &[_]OperandKind{} }, @@ -297,6 +387,8 @@ pub const OperandKind = enum { .{ .name = "MakePointerVisibleKHR", .value = 0x0010, .parameters = &[_]OperandKind{.IdScope} }, .{ .name = "NonPrivatePointer", .value = 0x0020, .parameters = &[_]OperandKind{} }, .{ .name = "NonPrivatePointerKHR", .value = 0x0020, .parameters = &[_]OperandKind{} }, + .{ .name = "AliasScopeINTELMask", .value = 0x10000, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "NoAliasINTELMask", .value = 0x20000, .parameters = &[_]OperandKind{.IdRef} }, }, .KernelProfilingInfo => &[_]Enumerant{ .{ .name = "CmdExecTime", .value = 0x0001, .parameters = &[_]OperandKind{} }, @@ -313,6 +405,7 @@ pub const OperandKind = enum { .{ .name = "CullNoOpaqueKHR", .value = 0x0080, .parameters = &[_]OperandKind{} }, .{ .name = "SkipTrianglesKHR", .value = 0x0100, .parameters = &[_]OperandKind{} }, .{ .name = "SkipAABBsKHR", .value = 0x0200, .parameters = &[_]OperandKind{} }, + .{ .name = "ForceOpacityMicromap2StateEXT", .value = 0x0400, .parameters = &[_]OperandKind{} }, }, .FragmentShadingRate => &[_]Enumerant{ .{ .name = "Vertical2Pixels", .value = 0x0001, .parameters = &[_]OperandKind{} }, @@ -320,6 +413,10 @@ pub const OperandKind = enum { .{ .name = "Horizontal2Pixels", .value = 0x0004, .parameters = &[_]OperandKind{} }, .{ .name = "Horizontal4Pixels", .value = 0x0008, .parameters = &[_]OperandKind{} }, }, + .RawAccessChainOperands => &[_]Enumerant{ + .{ .name = "RobustnessPerComponentNV", .value = 0x0001, .parameters = &[_]OperandKind{} }, + .{ .name = "RobustnessPerElementNV", .value = 0x0002, .parameters = &[_]OperandKind{} }, + }, .SourceLanguage => &[_]Enumerant{ .{ .name = "Unknown", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ESSL", .value = 1, .parameters = &[_]OperandKind{} }, @@ -328,6 +425,12 @@ pub const OperandKind = enum { .{ .name = "OpenCL_CPP", .value = 4, .parameters = &[_]OperandKind{} }, .{ .name = "HLSL", .value = 5, .parameters = &[_]OperandKind{} }, .{ .name = "CPP_for_OpenCL", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "SYCL", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "HERO_C", .value = 8, .parameters = &[_]OperandKind{} }, + .{ .name = "NZSL", .value = 9, .parameters = &[_]OperandKind{} }, + .{ .name = "WGSL", .value = 10, .parameters = &[_]OperandKind{} }, + .{ .name = "Slang", .value = 11, .parameters = &[_]OperandKind{} }, + .{ .name = "Zig", .value = 12, .parameters = &[_]OperandKind{} }, }, .ExecutionModel => &[_]Enumerant{ .{ .name = "Vertex", .value = 0, .parameters = &[_]OperandKind{} }, @@ -351,6 +454,8 @@ pub const OperandKind = enum { .{ .name = "MissKHR", .value = 5317, .parameters = &[_]OperandKind{} }, .{ .name = "CallableNV", .value = 5318, .parameters = &[_]OperandKind{} }, .{ .name = "CallableKHR", .value = 5318, .parameters = &[_]OperandKind{} }, + .{ .name = "TaskEXT", .value = 5364, .parameters = &[_]OperandKind{} }, + .{ .name = "MeshEXT", .value = 5365, .parameters = &[_]OperandKind{} }, }, .AddressingModel => &[_]Enumerant{ .{ .name = "Logical", .value = 0, .parameters = &[_]OperandKind{} }, @@ -405,6 +510,9 @@ pub const OperandKind = enum { .{ .name = "SubgroupsPerWorkgroupId", .value = 37, .parameters = &[_]OperandKind{.IdRef} }, .{ .name = "LocalSizeId", .value = 38, .parameters = &[_]OperandKind{ .IdRef, .IdRef, .IdRef } }, .{ .name = "LocalSizeHintId", .value = 39, .parameters = &[_]OperandKind{ .IdRef, .IdRef, .IdRef } }, + .{ .name = "NonCoherentColorAttachmentReadEXT", .value = 4169, .parameters = &[_]OperandKind{} }, + .{ .name = "NonCoherentDepthAttachmentReadEXT", .value = 4170, .parameters = &[_]OperandKind{} }, + .{ .name = "NonCoherentStencilAttachmentReadEXT", .value = 4171, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupUniformControlFlowKHR", .value = 4421, .parameters = &[_]OperandKind{} }, .{ .name = "PostDepthCoverage", .value = 4446, .parameters = &[_]OperandKind{} }, .{ .name = "DenormPreserve", .value = 4459, .parameters = &[_]OperandKind{.LiteralInteger} }, @@ -412,12 +520,29 @@ pub const OperandKind = enum { .{ .name = "SignedZeroInfNanPreserve", .value = 4461, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "RoundingModeRTE", .value = 4462, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "RoundingModeRTZ", .value = 4463, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "EarlyAndLateFragmentTestsAMD", .value = 5017, .parameters = &[_]OperandKind{} }, .{ .name = "StencilRefReplacingEXT", .value = 5027, .parameters = &[_]OperandKind{} }, + .{ .name = "CoalescingAMDX", .value = 5069, .parameters = &[_]OperandKind{} }, + .{ .name = "MaxNodeRecursionAMDX", .value = 5071, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "StaticNumWorkgroupsAMDX", .value = 5072, .parameters = &[_]OperandKind{ .IdRef, .IdRef, .IdRef } }, + .{ .name = "ShaderIndexAMDX", .value = 5073, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "MaxNumWorkgroupsAMDX", .value = 5077, .parameters = &[_]OperandKind{ .IdRef, .IdRef, .IdRef } }, + .{ .name = "StencilRefUnchangedFrontAMD", .value = 5079, .parameters = &[_]OperandKind{} }, + .{ .name = "StencilRefGreaterFrontAMD", .value = 5080, .parameters = &[_]OperandKind{} }, + .{ .name = "StencilRefLessFrontAMD", .value = 5081, .parameters = &[_]OperandKind{} }, + .{ .name = "StencilRefUnchangedBackAMD", .value = 5082, .parameters = &[_]OperandKind{} }, + .{ .name = "StencilRefGreaterBackAMD", .value = 5083, .parameters = &[_]OperandKind{} }, + .{ .name = "StencilRefLessBackAMD", .value = 5084, .parameters = &[_]OperandKind{} }, + .{ .name = "QuadDerivativesKHR", .value = 5088, .parameters = &[_]OperandKind{} }, + .{ .name = "RequireFullQuadsKHR", .value = 5089, .parameters = &[_]OperandKind{} }, .{ .name = "OutputLinesNV", .value = 5269, .parameters = &[_]OperandKind{} }, + .{ .name = "OutputLinesEXT", .value = 5269, .parameters = &[_]OperandKind{} }, .{ .name = "OutputPrimitivesNV", .value = 5270, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "OutputPrimitivesEXT", .value = 5270, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "DerivativeGroupQuadsNV", .value = 5289, .parameters = &[_]OperandKind{} }, .{ .name = "DerivativeGroupLinearNV", .value = 5290, .parameters = &[_]OperandKind{} }, .{ .name = "OutputTrianglesNV", .value = 5298, .parameters = &[_]OperandKind{} }, + .{ .name = "OutputTrianglesEXT", .value = 5298, .parameters = &[_]OperandKind{} }, .{ .name = "PixelInterlockOrderedEXT", .value = 5366, .parameters = &[_]OperandKind{} }, .{ .name = "PixelInterlockUnorderedEXT", .value = 5367, .parameters = &[_]OperandKind{} }, .{ .name = "SampleInterlockOrderedEXT", .value = 5368, .parameters = &[_]OperandKind{} }, @@ -434,6 +559,14 @@ pub const OperandKind = enum { .{ .name = "NoGlobalOffsetINTEL", .value = 5895, .parameters = &[_]OperandKind{} }, .{ .name = "NumSIMDWorkitemsINTEL", .value = 5896, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "SchedulerTargetFmaxMhzINTEL", .value = 5903, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MaximallyReconvergesKHR", .value = 6023, .parameters = &[_]OperandKind{} }, + .{ .name = "FPFastMathDefault", .value = 6028, .parameters = &[_]OperandKind{ .IdRef, .IdRef } }, + .{ .name = "StreamingInterfaceINTEL", .value = 6154, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "RegisterMapInterfaceINTEL", .value = 6160, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "NamedBarrierCountINTEL", .value = 6417, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MaximumRegistersINTEL", .value = 6461, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MaximumRegistersIdINTEL", .value = 6462, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "NamedMaximumRegistersINTEL", .value = 6463, .parameters = &[_]OperandKind{.NamedMaximumNumberOfRegisters} }, }, .StorageClass => &[_]Enumerant{ .{ .name = "UniformConstant", .value = 0, .parameters = &[_]OperandKind{} }, @@ -449,6 +582,9 @@ pub const OperandKind = enum { .{ .name = "AtomicCounter", .value = 10, .parameters = &[_]OperandKind{} }, .{ .name = "Image", .value = 11, .parameters = &[_]OperandKind{} }, .{ .name = "StorageBuffer", .value = 12, .parameters = &[_]OperandKind{} }, + .{ .name = "TileImageEXT", .value = 4172, .parameters = &[_]OperandKind{} }, + .{ .name = "NodePayloadAMDX", .value = 5068, .parameters = &[_]OperandKind{} }, + .{ .name = "NodeOutputPayloadAMDX", .value = 5076, .parameters = &[_]OperandKind{} }, .{ .name = "CallableDataNV", .value = 5328, .parameters = &[_]OperandKind{} }, .{ .name = "CallableDataKHR", .value = 5328, .parameters = &[_]OperandKind{} }, .{ .name = "IncomingCallableDataNV", .value = 5329, .parameters = &[_]OperandKind{} }, @@ -463,6 +599,8 @@ pub const OperandKind = enum { .{ .name = "ShaderRecordBufferKHR", .value = 5343, .parameters = &[_]OperandKind{} }, .{ .name = "PhysicalStorageBuffer", .value = 5349, .parameters = &[_]OperandKind{} }, .{ .name = "PhysicalStorageBufferEXT", .value = 5349, .parameters = &[_]OperandKind{} }, + .{ .name = "HitObjectAttributeNV", .value = 5385, .parameters = &[_]OperandKind{} }, + .{ .name = "TaskPayloadWorkgroupEXT", .value = 5402, .parameters = &[_]OperandKind{} }, .{ .name = "CodeSectionINTEL", .value = 5605, .parameters = &[_]OperandKind{} }, .{ .name = "DeviceOnlyINTEL", .value = 5936, .parameters = &[_]OperandKind{} }, .{ .name = "HostOnlyINTEL", .value = 5937, .parameters = &[_]OperandKind{} }, @@ -475,6 +613,7 @@ pub const OperandKind = enum { .{ .name = "Rect", .value = 4, .parameters = &[_]OperandKind{} }, .{ .name = "Buffer", .value = 5, .parameters = &[_]OperandKind{} }, .{ .name = "SubpassData", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "TileImageDataEXT", .value = 4173, .parameters = &[_]OperandKind{} }, }, .SamplerAddressingMode => &[_]Enumerant{ .{ .name = "None", .value = 0, .parameters = &[_]OperandKind{} }, @@ -571,6 +710,8 @@ pub const OperandKind = enum { .{ .name = "Float", .value = 14, .parameters = &[_]OperandKind{} }, .{ .name = "UnormInt24", .value = 15, .parameters = &[_]OperandKind{} }, .{ .name = "UnormInt101010_2", .value = 16, .parameters = &[_]OperandKind{} }, + .{ .name = "UnsignedIntRaw10EXT", .value = 19, .parameters = &[_]OperandKind{} }, + .{ .name = "UnsignedIntRaw12EXT", .value = 20, .parameters = &[_]OperandKind{} }, }, .FPRoundingMode => &[_]Enumerant{ .{ .name = "RTE", .value = 0, .parameters = &[_]OperandKind{} }, @@ -612,6 +753,12 @@ pub const OperandKind = enum { .{ .name = "WriteOnly", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "ReadWrite", .value = 2, .parameters = &[_]OperandKind{} }, }, + .HostAccessQualifier => &[_]Enumerant{ + .{ .name = "NoneINTEL", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "ReadINTEL", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "WriteINTEL", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "ReadWriteINTEL", .value = 3, .parameters = &[_]OperandKind{} }, + }, .FunctionParameterAttribute => &[_]Enumerant{ .{ .name = "Zext", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Sext", .value = 1, .parameters = &[_]OperandKind{} }, @@ -621,6 +768,7 @@ pub const OperandKind = enum { .{ .name = "NoCapture", .value = 5, .parameters = &[_]OperandKind{} }, .{ .name = "NoWrite", .value = 6, .parameters = &[_]OperandKind{} }, .{ .name = "NoReadWrite", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "RuntimeAlignedINTEL", .value = 5940, .parameters = &[_]OperandKind{} }, }, .Decoration => &[_]Enumerant{ .{ .name = "RelaxedPrecision", .value = 0, .parameters = &[_]OperandKind{} }, @@ -672,12 +820,20 @@ pub const OperandKind = enum { .{ .name = "MaxByteOffsetId", .value = 47, .parameters = &[_]OperandKind{.IdRef} }, .{ .name = "NoSignedWrap", .value = 4469, .parameters = &[_]OperandKind{} }, .{ .name = "NoUnsignedWrap", .value = 4470, .parameters = &[_]OperandKind{} }, + .{ .name = "WeightTextureQCOM", .value = 4487, .parameters = &[_]OperandKind{} }, + .{ .name = "BlockMatchTextureQCOM", .value = 4488, .parameters = &[_]OperandKind{} }, + .{ .name = "BlockMatchSamplerQCOM", .value = 4499, .parameters = &[_]OperandKind{} }, .{ .name = "ExplicitInterpAMD", .value = 4999, .parameters = &[_]OperandKind{} }, + .{ .name = "NodeSharesPayloadLimitsWithAMDX", .value = 5019, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "NodeMaxPayloadsAMDX", .value = 5020, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "TrackFinishWritingAMDX", .value = 5078, .parameters = &[_]OperandKind{} }, + .{ .name = "PayloadNodeNameAMDX", .value = 5091, .parameters = &[_]OperandKind{.LiteralString} }, .{ .name = "OverrideCoverageNV", .value = 5248, .parameters = &[_]OperandKind{} }, .{ .name = "PassthroughNV", .value = 5250, .parameters = &[_]OperandKind{} }, .{ .name = "ViewportRelativeNV", .value = 5252, .parameters = &[_]OperandKind{} }, .{ .name = "SecondaryViewportRelativeNV", .value = 5256, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "PerPrimitiveNV", .value = 5271, .parameters = &[_]OperandKind{} }, + .{ .name = "PerPrimitiveEXT", .value = 5271, .parameters = &[_]OperandKind{} }, .{ .name = "PerViewNV", .value = 5272, .parameters = &[_]OperandKind{} }, .{ .name = "PerTaskNV", .value = 5273, .parameters = &[_]OperandKind{} }, .{ .name = "PerVertexKHR", .value = 5285, .parameters = &[_]OperandKind{} }, @@ -688,6 +844,7 @@ pub const OperandKind = enum { .{ .name = "RestrictPointerEXT", .value = 5355, .parameters = &[_]OperandKind{} }, .{ .name = "AliasedPointer", .value = 5356, .parameters = &[_]OperandKind{} }, .{ .name = "AliasedPointerEXT", .value = 5356, .parameters = &[_]OperandKind{} }, + .{ .name = "HitObjectShaderRecordBufferNV", .value = 5386, .parameters = &[_]OperandKind{} }, .{ .name = "BindlessSamplerNV", .value = 5398, .parameters = &[_]OperandKind{} }, .{ .name = "BindlessImageNV", .value = 5399, .parameters = &[_]OperandKind{} }, .{ .name = "BoundSamplerNV", .value = 5400, .parameters = &[_]OperandKind{} }, @@ -720,18 +877,45 @@ pub const OperandKind = enum { .{ .name = "MergeINTEL", .value = 5834, .parameters = &[_]OperandKind{ .LiteralString, .LiteralString } }, .{ .name = "BankBitsINTEL", .value = 5835, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "ForcePow2DepthINTEL", .value = 5836, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "StridesizeINTEL", .value = 5883, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "WordsizeINTEL", .value = 5884, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "TrueDualPortINTEL", .value = 5885, .parameters = &[_]OperandKind{} }, .{ .name = "BurstCoalesceINTEL", .value = 5899, .parameters = &[_]OperandKind{} }, .{ .name = "CacheSizeINTEL", .value = 5900, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "DontStaticallyCoalesceINTEL", .value = 5901, .parameters = &[_]OperandKind{} }, .{ .name = "PrefetchINTEL", .value = 5902, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "StallEnableINTEL", .value = 5905, .parameters = &[_]OperandKind{} }, .{ .name = "FuseLoopsInFunctionINTEL", .value = 5907, .parameters = &[_]OperandKind{} }, + .{ .name = "MathOpDSPModeINTEL", .value = 5909, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } }, + .{ .name = "AliasScopeINTEL", .value = 5914, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "NoAliasINTEL", .value = 5915, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "InitiationIntervalINTEL", .value = 5917, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MaxConcurrencyINTEL", .value = 5918, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "PipelineEnableINTEL", .value = 5919, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "BufferLocationINTEL", .value = 5921, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "IOPipeStorageINTEL", .value = 5944, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "FunctionFloatingPointModeINTEL", .value = 6080, .parameters = &[_]OperandKind{ .LiteralInteger, .FPOperationMode } }, .{ .name = "SingleElementVectorINTEL", .value = 6085, .parameters = &[_]OperandKind{} }, .{ .name = "VectorComputeCallableFunctionINTEL", .value = 6087, .parameters = &[_]OperandKind{} }, .{ .name = "MediaBlockIOINTEL", .value = 6140, .parameters = &[_]OperandKind{} }, + .{ .name = "StallFreeINTEL", .value = 6151, .parameters = &[_]OperandKind{} }, + .{ .name = "FPMaxErrorDecorationINTEL", .value = 6170, .parameters = &[_]OperandKind{.LiteralFloat} }, + .{ .name = "LatencyControlLabelINTEL", .value = 6172, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "LatencyControlConstraintINTEL", .value = 6173, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger, .LiteralInteger } }, + .{ .name = "ConduitKernelArgumentINTEL", .value = 6175, .parameters = &[_]OperandKind{} }, + .{ .name = "RegisterMapKernelArgumentINTEL", .value = 6176, .parameters = &[_]OperandKind{} }, + .{ .name = "MMHostInterfaceAddressWidthINTEL", .value = 6177, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MMHostInterfaceDataWidthINTEL", .value = 6178, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MMHostInterfaceLatencyINTEL", .value = 6179, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MMHostInterfaceReadWriteModeINTEL", .value = 6180, .parameters = &[_]OperandKind{.AccessQualifier} }, + .{ .name = "MMHostInterfaceMaxBurstINTEL", .value = 6181, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "MMHostInterfaceWaitRequestINTEL", .value = 6182, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "StableKernelArgumentINTEL", .value = 6183, .parameters = &[_]OperandKind{} }, + .{ .name = "HostAccessINTEL", .value = 6188, .parameters = &[_]OperandKind{ .HostAccessQualifier, .LiteralString } }, + .{ .name = "InitModeINTEL", .value = 6190, .parameters = &[_]OperandKind{.InitializationModeQualifier} }, + .{ .name = "ImplementInRegisterMapINTEL", .value = 6191, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "CacheControlLoadINTEL", .value = 6442, .parameters = &[_]OperandKind{ .LiteralInteger, .LoadCacheControl } }, + .{ .name = "CacheControlStoreINTEL", .value = 6443, .parameters = &[_]OperandKind{ .LiteralInteger, .StoreCacheControl } }, }, .BuiltIn => &[_]Enumerant{ .{ .name = "Position", .value = 0, .parameters = &[_]OperandKind{} }, @@ -775,6 +959,11 @@ pub const OperandKind = enum { .{ .name = "SubgroupLocalInvocationId", .value = 41, .parameters = &[_]OperandKind{} }, .{ .name = "VertexIndex", .value = 42, .parameters = &[_]OperandKind{} }, .{ .name = "InstanceIndex", .value = 43, .parameters = &[_]OperandKind{} }, + .{ .name = "CoreIDARM", .value = 4160, .parameters = &[_]OperandKind{} }, + .{ .name = "CoreCountARM", .value = 4161, .parameters = &[_]OperandKind{} }, + .{ .name = "CoreMaxIDARM", .value = 4162, .parameters = &[_]OperandKind{} }, + .{ .name = "WarpIDARM", .value = 4163, .parameters = &[_]OperandKind{} }, + .{ .name = "WarpMaxIDARM", .value = 4164, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupEqMask", .value = 4416, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupEqMaskKHR", .value = 4416, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupGeMask", .value = 4417, .parameters = &[_]OperandKind{} }, @@ -800,6 +989,8 @@ pub const OperandKind = enum { .{ .name = "BaryCoordSmoothSampleAMD", .value = 4997, .parameters = &[_]OperandKind{} }, .{ .name = "BaryCoordPullModelAMD", .value = 4998, .parameters = &[_]OperandKind{} }, .{ .name = "FragStencilRefEXT", .value = 5014, .parameters = &[_]OperandKind{} }, + .{ .name = "CoalescedInputCountAMDX", .value = 5021, .parameters = &[_]OperandKind{} }, + .{ .name = "ShaderIndexAMDX", .value = 5073, .parameters = &[_]OperandKind{} }, .{ .name = "ViewportMaskNV", .value = 5253, .parameters = &[_]OperandKind{} }, .{ .name = "SecondaryPositionNV", .value = 5257, .parameters = &[_]OperandKind{} }, .{ .name = "SecondaryViewportMaskNV", .value = 5258, .parameters = &[_]OperandKind{} }, @@ -822,6 +1013,10 @@ pub const OperandKind = enum { .{ .name = "FragmentSizeNV", .value = 5292, .parameters = &[_]OperandKind{} }, .{ .name = "FragInvocationCountEXT", .value = 5293, .parameters = &[_]OperandKind{} }, .{ .name = "InvocationsPerPixelNV", .value = 5293, .parameters = &[_]OperandKind{} }, + .{ .name = "PrimitivePointIndicesEXT", .value = 5294, .parameters = &[_]OperandKind{} }, + .{ .name = "PrimitiveLineIndicesEXT", .value = 5295, .parameters = &[_]OperandKind{} }, + .{ .name = "PrimitiveTriangleIndicesEXT", .value = 5296, .parameters = &[_]OperandKind{} }, + .{ .name = "CullPrimitiveEXT", .value = 5299, .parameters = &[_]OperandKind{} }, .{ .name = "LaunchIdNV", .value = 5319, .parameters = &[_]OperandKind{} }, .{ .name = "LaunchIdKHR", .value = 5319, .parameters = &[_]OperandKind{} }, .{ .name = "LaunchSizeNV", .value = 5320, .parameters = &[_]OperandKind{} }, @@ -848,6 +1043,9 @@ pub const OperandKind = enum { .{ .name = "HitKindNV", .value = 5333, .parameters = &[_]OperandKind{} }, .{ .name = "HitKindKHR", .value = 5333, .parameters = &[_]OperandKind{} }, .{ .name = "CurrentRayTimeNV", .value = 5334, .parameters = &[_]OperandKind{} }, + .{ .name = "HitTriangleVertexPositionsKHR", .value = 5335, .parameters = &[_]OperandKind{} }, + .{ .name = "HitMicroTriangleVertexPositionsNV", .value = 5337, .parameters = &[_]OperandKind{} }, + .{ .name = "HitMicroTriangleVertexBarycentricsNV", .value = 5344, .parameters = &[_]OperandKind{} }, .{ .name = "IncomingRayFlagsNV", .value = 5351, .parameters = &[_]OperandKind{} }, .{ .name = "IncomingRayFlagsKHR", .value = 5351, .parameters = &[_]OperandKind{} }, .{ .name = "RayGeometryIndexKHR", .value = 5352, .parameters = &[_]OperandKind{} }, @@ -855,6 +1053,9 @@ pub const OperandKind = enum { .{ .name = "SMCountNV", .value = 5375, .parameters = &[_]OperandKind{} }, .{ .name = "WarpIDNV", .value = 5376, .parameters = &[_]OperandKind{} }, .{ .name = "SMIDNV", .value = 5377, .parameters = &[_]OperandKind{} }, + .{ .name = "HitKindFrontFacingMicroTriangleNV", .value = 5405, .parameters = &[_]OperandKind{} }, + .{ .name = "HitKindBackFacingMicroTriangleNV", .value = 5406, .parameters = &[_]OperandKind{} }, + .{ .name = "CullMaskKHR", .value = 6021, .parameters = &[_]OperandKind{} }, }, .Scope => &[_]Enumerant{ .{ .name = "CrossDevice", .value = 0, .parameters = &[_]OperandKind{} }, @@ -951,6 +1152,10 @@ pub const OperandKind = enum { .{ .name = "ShaderLayer", .value = 69, .parameters = &[_]OperandKind{} }, .{ .name = "ShaderViewportIndex", .value = 70, .parameters = &[_]OperandKind{} }, .{ .name = "UniformDecoration", .value = 71, .parameters = &[_]OperandKind{} }, + .{ .name = "CoreBuiltinsARM", .value = 4165, .parameters = &[_]OperandKind{} }, + .{ .name = "TileImageColorReadAccessEXT", .value = 4166, .parameters = &[_]OperandKind{} }, + .{ .name = "TileImageDepthReadAccessEXT", .value = 4167, .parameters = &[_]OperandKind{} }, + .{ .name = "TileImageStencilReadAccessEXT", .value = 4168, .parameters = &[_]OperandKind{} }, .{ .name = "FragmentShadingRateKHR", .value = 4422, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupBallotKHR", .value = 4423, .parameters = &[_]OperandKind{} }, .{ .name = "DrawParameters", .value = 4427, .parameters = &[_]OperandKind{} }, @@ -982,6 +1187,10 @@ pub const OperandKind = enum { .{ .name = "RayQueryKHR", .value = 4472, .parameters = &[_]OperandKind{} }, .{ .name = "RayTraversalPrimitiveCullingKHR", .value = 4478, .parameters = &[_]OperandKind{} }, .{ .name = "RayTracingKHR", .value = 4479, .parameters = &[_]OperandKind{} }, + .{ .name = "TextureSampleWeightedQCOM", .value = 4484, .parameters = &[_]OperandKind{} }, + .{ .name = "TextureBoxFilterQCOM", .value = 4485, .parameters = &[_]OperandKind{} }, + .{ .name = "TextureBlockMatchQCOM", .value = 4486, .parameters = &[_]OperandKind{} }, + .{ .name = "TextureBlockMatch2QCOM", .value = 4498, .parameters = &[_]OperandKind{} }, .{ .name = "Float16ImageAMD", .value = 5008, .parameters = &[_]OperandKind{} }, .{ .name = "ImageGatherBiasLodAMD", .value = 5009, .parameters = &[_]OperandKind{} }, .{ .name = "FragmentMaskAMD", .value = 5010, .parameters = &[_]OperandKind{} }, @@ -989,6 +1198,8 @@ pub const OperandKind = enum { .{ .name = "ImageReadWriteLodAMD", .value = 5015, .parameters = &[_]OperandKind{} }, .{ .name = "Int64ImageEXT", .value = 5016, .parameters = &[_]OperandKind{} }, .{ .name = "ShaderClockKHR", .value = 5055, .parameters = &[_]OperandKind{} }, + .{ .name = "ShaderEnqueueAMDX", .value = 5067, .parameters = &[_]OperandKind{} }, + .{ .name = "QuadControlKHR", .value = 5087, .parameters = &[_]OperandKind{} }, .{ .name = "SampleMaskOverrideCoverageNV", .value = 5249, .parameters = &[_]OperandKind{} }, .{ .name = "GeometryShaderPassthroughNV", .value = 5251, .parameters = &[_]OperandKind{} }, .{ .name = "ShaderViewportIndexLayerEXT", .value = 5254, .parameters = &[_]OperandKind{} }, @@ -999,6 +1210,7 @@ pub const OperandKind = enum { .{ .name = "FragmentFullyCoveredEXT", .value = 5265, .parameters = &[_]OperandKind{} }, .{ .name = "MeshShadingNV", .value = 5266, .parameters = &[_]OperandKind{} }, .{ .name = "ImageFootprintNV", .value = 5282, .parameters = &[_]OperandKind{} }, + .{ .name = "MeshShadingEXT", .value = 5283, .parameters = &[_]OperandKind{} }, .{ .name = "FragmentBarycentricKHR", .value = 5284, .parameters = &[_]OperandKind{} }, .{ .name = "FragmentBarycentricNV", .value = 5284, .parameters = &[_]OperandKind{} }, .{ .name = "ComputeDerivativeGroupQuadsNV", .value = 5288, .parameters = &[_]OperandKind{} }, @@ -1029,6 +1241,7 @@ pub const OperandKind = enum { .{ .name = "UniformTexelBufferArrayNonUniformIndexingEXT", .value = 5311, .parameters = &[_]OperandKind{} }, .{ .name = "StorageTexelBufferArrayNonUniformIndexing", .value = 5312, .parameters = &[_]OperandKind{} }, .{ .name = "StorageTexelBufferArrayNonUniformIndexingEXT", .value = 5312, .parameters = &[_]OperandKind{} }, + .{ .name = "RayTracingPositionFetchKHR", .value = 5336, .parameters = &[_]OperandKind{} }, .{ .name = "RayTracingNV", .value = 5340, .parameters = &[_]OperandKind{} }, .{ .name = "RayTracingMotionBlurNV", .value = 5341, .parameters = &[_]OperandKind{} }, .{ .name = "VulkanMemoryModel", .value = 5345, .parameters = &[_]OperandKind{} }, @@ -1046,7 +1259,14 @@ pub const OperandKind = enum { .{ .name = "FragmentShaderPixelInterlockEXT", .value = 5378, .parameters = &[_]OperandKind{} }, .{ .name = "DemoteToHelperInvocation", .value = 5379, .parameters = &[_]OperandKind{} }, .{ .name = "DemoteToHelperInvocationEXT", .value = 5379, .parameters = &[_]OperandKind{} }, + .{ .name = "DisplacementMicromapNV", .value = 5380, .parameters = &[_]OperandKind{} }, + .{ .name = "RayTracingOpacityMicromapEXT", .value = 5381, .parameters = &[_]OperandKind{} }, + .{ .name = "ShaderInvocationReorderNV", .value = 5383, .parameters = &[_]OperandKind{} }, .{ .name = "BindlessTextureNV", .value = 5390, .parameters = &[_]OperandKind{} }, + .{ .name = "RayQueryPositionFetchKHR", .value = 5391, .parameters = &[_]OperandKind{} }, + .{ .name = "AtomicFloat16VectorNV", .value = 5404, .parameters = &[_]OperandKind{} }, + .{ .name = "RayTracingDisplacementMicromapNV", .value = 5409, .parameters = &[_]OperandKind{} }, + .{ .name = "RawAccessChainsNV", .value = 5414, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupShuffleINTEL", .value = 5568, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupBufferBlockIOINTEL", .value = 5569, .parameters = &[_]OperandKind{} }, .{ .name = "SubgroupImageBlockIOINTEL", .value = 5570, .parameters = &[_]OperandKind{} }, @@ -1079,9 +1299,13 @@ pub const OperandKind = enum { .{ .name = "FPGAMemoryAccessesINTEL", .value = 5898, .parameters = &[_]OperandKind{} }, .{ .name = "FPGAClusterAttributesINTEL", .value = 5904, .parameters = &[_]OperandKind{} }, .{ .name = "LoopFuseINTEL", .value = 5906, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGADSPControlINTEL", .value = 5908, .parameters = &[_]OperandKind{} }, + .{ .name = "MemoryAccessAliasingINTEL", .value = 5910, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGAInvocationPipeliningAttributesINTEL", .value = 5916, .parameters = &[_]OperandKind{} }, .{ .name = "FPGABufferLocationINTEL", .value = 5920, .parameters = &[_]OperandKind{} }, .{ .name = "ArbitraryPrecisionFixedPointINTEL", .value = 5922, .parameters = &[_]OperandKind{} }, .{ .name = "USMStorageClassesINTEL", .value = 5935, .parameters = &[_]OperandKind{} }, + .{ .name = "RuntimeAlignedAttributeINTEL", .value = 5939, .parameters = &[_]OperandKind{} }, .{ .name = "IOPipesINTEL", .value = 5943, .parameters = &[_]OperandKind{} }, .{ .name = "BlockingPipesINTEL", .value = 5945, .parameters = &[_]OperandKind{} }, .{ .name = "FPGARegINTEL", .value = 5948, .parameters = &[_]OperandKind{} }, @@ -1093,13 +1317,30 @@ pub const OperandKind = enum { .{ .name = "DotProductInput4x8BitPackedKHR", .value = 6018, .parameters = &[_]OperandKind{} }, .{ .name = "DotProduct", .value = 6019, .parameters = &[_]OperandKind{} }, .{ .name = "DotProductKHR", .value = 6019, .parameters = &[_]OperandKind{} }, + .{ .name = "RayCullMaskKHR", .value = 6020, .parameters = &[_]OperandKind{} }, + .{ .name = "CooperativeMatrixKHR", .value = 6022, .parameters = &[_]OperandKind{} }, .{ .name = "BitInstructions", .value = 6025, .parameters = &[_]OperandKind{} }, + .{ .name = "GroupNonUniformRotateKHR", .value = 6026, .parameters = &[_]OperandKind{} }, + .{ .name = "FloatControls2", .value = 6029, .parameters = &[_]OperandKind{} }, .{ .name = "AtomicFloat32AddEXT", .value = 6033, .parameters = &[_]OperandKind{} }, .{ .name = "AtomicFloat64AddEXT", .value = 6034, .parameters = &[_]OperandKind{} }, - .{ .name = "LongConstantCompositeINTEL", .value = 6089, .parameters = &[_]OperandKind{} }, + .{ .name = "LongCompositesINTEL", .value = 6089, .parameters = &[_]OperandKind{} }, .{ .name = "OptNoneINTEL", .value = 6094, .parameters = &[_]OperandKind{} }, .{ .name = "AtomicFloat16AddEXT", .value = 6095, .parameters = &[_]OperandKind{} }, .{ .name = "DebugInfoModuleINTEL", .value = 6114, .parameters = &[_]OperandKind{} }, + .{ .name = "BFloat16ConversionINTEL", .value = 6115, .parameters = &[_]OperandKind{} }, + .{ .name = "SplitBarrierINTEL", .value = 6141, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGAClusterAttributesV2INTEL", .value = 6150, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGAKernelAttributesv2INTEL", .value = 6161, .parameters = &[_]OperandKind{} }, + .{ .name = "FPMaxErrorINTEL", .value = 6169, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGALatencyControlINTEL", .value = 6171, .parameters = &[_]OperandKind{} }, + .{ .name = "FPGAArgumentInterfacesINTEL", .value = 6174, .parameters = &[_]OperandKind{} }, + .{ .name = "GlobalVariableHostAccessINTEL", .value = 6187, .parameters = &[_]OperandKind{} }, + .{ .name = "GlobalVariableFPGADecorationsINTEL", .value = 6189, .parameters = &[_]OperandKind{} }, + .{ .name = "GroupUniformArithmeticKHR", .value = 6400, .parameters = &[_]OperandKind{} }, + .{ .name = "MaskedGatherScatterINTEL", .value = 6427, .parameters = &[_]OperandKind{} }, + .{ .name = "CacheControlsINTEL", .value = 6441, .parameters = &[_]OperandKind{} }, + .{ .name = "RegisterLimitsINTEL", .value = 6460, .parameters = &[_]OperandKind{} }, }, .RayQueryIntersection => &[_]Enumerant{ .{ .name = "RayQueryCandidateIntersectionKHR", .value = 0, .parameters = &[_]OperandKind{} }, @@ -1118,6 +1359,43 @@ pub const OperandKind = enum { .{ .name = "PackedVectorFormat4x8Bit", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "PackedVectorFormat4x8BitKHR", .value = 0, .parameters = &[_]OperandKind{} }, }, + .CooperativeMatrixOperands => &[_]Enumerant{ + .{ .name = "NoneKHR", .value = 0x0000, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixASignedComponentsKHR", .value = 0x0001, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixBSignedComponentsKHR", .value = 0x0002, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixCSignedComponentsKHR", .value = 0x0004, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixResultSignedComponentsKHR", .value = 0x0008, .parameters = &[_]OperandKind{} }, + .{ .name = "SaturatingAccumulationKHR", .value = 0x0010, .parameters = &[_]OperandKind{} }, + }, + .CooperativeMatrixLayout => &[_]Enumerant{ + .{ .name = "RowMajorKHR", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "ColumnMajorKHR", .value = 1, .parameters = &[_]OperandKind{} }, + }, + .CooperativeMatrixUse => &[_]Enumerant{ + .{ .name = "MatrixAKHR", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixBKHR", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "MatrixAccumulatorKHR", .value = 2, .parameters = &[_]OperandKind{} }, + }, + .InitializationModeQualifier => &[_]Enumerant{ + .{ .name = "InitOnDeviceReprogramINTEL", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "InitOnDeviceResetINTEL", .value = 1, .parameters = &[_]OperandKind{} }, + }, + .LoadCacheControl => &[_]Enumerant{ + .{ .name = "UncachedINTEL", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "CachedINTEL", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "StreamingINTEL", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "InvalidateAfterReadINTEL", .value = 3, .parameters = &[_]OperandKind{} }, + .{ .name = "ConstCachedINTEL", .value = 4, .parameters = &[_]OperandKind{} }, + }, + .StoreCacheControl => &[_]Enumerant{ + .{ .name = "UncachedINTEL", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "WriteThroughINTEL", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "WriteBackINTEL", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "StreamingINTEL", .value = 3, .parameters = &[_]OperandKind{} }, + }, + .NamedMaximumNumberOfRegisters => &[_]Enumerant{ + .{ .name = "AutoINTEL", .value = 0, .parameters = &[_]OperandKind{} }, + }, .IdResultType => unreachable, .IdResult => unreachable, .IdMemorySemantics => unreachable, @@ -1125,12 +1403,182 @@ pub const OperandKind = enum { .IdRef => unreachable, .LiteralInteger => unreachable, .LiteralString => unreachable, + .LiteralFloat => unreachable, .LiteralContextDependentNumber => unreachable, .LiteralExtInstInteger => unreachable, .LiteralSpecConstantOpInteger => unreachable, .PairLiteralIntegerIdRef => unreachable, .PairIdRefLiteralInteger => unreachable, .PairIdRefIdRef => unreachable, + .@"OpenCL.DebugInfo.100.DebugInfoFlags" => &[_]Enumerant{ + .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsLocal", .value = 0x04, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsDefinition", .value = 0x08, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagFwdDecl", .value = 0x10, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagArtificial", .value = 0x20, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagExplicit", .value = 0x40, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagPrototyped", .value = 0x80, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagObjectPointer", .value = 0x100, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagStaticMember", .value = 0x200, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIndirectVariable", .value = 0x400, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagLValueReference", .value = 0x800, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsEnumClass", .value = 0x4000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} }, + }, + .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ + .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "Float", .value = 3, .parameters = &[_]OperandKind{} }, + .{ .name = "Signed", .value = 4, .parameters = &[_]OperandKind{} }, + .{ .name = "SignedChar", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} }, + }, + .@"OpenCL.DebugInfo.100.DebugCompositeType" => &[_]Enumerant{ + .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, + }, + .@"OpenCL.DebugInfo.100.DebugTypeQualifier" => &[_]Enumerant{ + .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} }, + }, + .@"OpenCL.DebugInfo.100.DebugOperation" => &[_]Enumerant{ + .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "PlusUconst", .value = 3, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "BitPiece", .value = 4, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } }, + .{ .name = "Swap", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "Xderef", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "StackValue", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } }, + }, + .@"OpenCL.DebugInfo.100.DebugImportedEntity" => &[_]Enumerant{ + .{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" => &[_]Enumerant{ + .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsLocal", .value = 0x04, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsDefinition", .value = 0x08, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagFwdDecl", .value = 0x10, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagArtificial", .value = 0x20, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagExplicit", .value = 0x40, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagPrototyped", .value = 0x80, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagObjectPointer", .value = 0x100, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagStaticMember", .value = 0x200, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIndirectVariable", .value = 0x400, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagLValueReference", .value = 0x800, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsEnumClass", .value = 0x4000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagUnknownPhysicalLayout", .value = 0x20000, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" => &[_]Enumerant{ + .{ .name = "IdentifierPossibleDuplicates", .value = 0x01, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ + .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "Float", .value = 3, .parameters = &[_]OperandKind{} }, + .{ .name = "Signed", .value = 4, .parameters = &[_]OperandKind{} }, + .{ .name = "SignedChar", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" => &[_]Enumerant{ + .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" => &[_]Enumerant{ + .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugOperation" => &[_]Enumerant{ + .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "PlusUconst", .value = 3, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "BitPiece", .value = 4, .parameters = &[_]OperandKind{ .IdRef, .IdRef } }, + .{ .name = "Swap", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "Xderef", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "StackValue", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.IdRef} }, + .{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .IdRef, .IdRef } }, + }, + .@"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" => &[_]Enumerant{ + .{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} }, + }, + .@"NonSemantic.ClspvReflection.6.KernelPropertyFlags" => &[_]Enumerant{ + .{ .name = "MayUsePrintf", .value = 0x1, .parameters = &[_]OperandKind{} }, + }, + .@"DebugInfo.DebugInfoFlags" => &[_]Enumerant{ + .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsLocal", .value = 0x04, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsDefinition", .value = 0x08, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagFwdDecl", .value = 0x10, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagArtificial", .value = 0x20, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagExplicit", .value = 0x40, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagPrototyped", .value = 0x80, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagObjectPointer", .value = 0x100, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagStaticMember", .value = 0x200, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIndirectVariable", .value = 0x400, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagLValueReference", .value = 0x800, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &[_]OperandKind{} }, + .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &[_]OperandKind{} }, + }, + .@"DebugInfo.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ + .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "Float", .value = 4, .parameters = &[_]OperandKind{} }, + .{ .name = "Signed", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "SignedChar", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "Unsigned", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "UnsignedChar", .value = 8, .parameters = &[_]OperandKind{} }, + }, + .@"DebugInfo.DebugCompositeType" => &[_]Enumerant{ + .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, + }, + .@"DebugInfo.DebugTypeQualifier" => &[_]Enumerant{ + .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, + }, + .@"DebugInfo.DebugOperation" => &[_]Enumerant{ + .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, + .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, + .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, + .{ .name = "PlusUconst", .value = 3, .parameters = &[_]OperandKind{.LiteralInteger} }, + .{ .name = "BitPiece", .value = 4, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } }, + .{ .name = "Swap", .value = 5, .parameters = &[_]OperandKind{} }, + .{ .name = "Xderef", .value = 6, .parameters = &[_]OperandKind{} }, + .{ .name = "StackValue", .value = 7, .parameters = &[_]OperandKind{} }, + .{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.LiteralInteger} }, + }, }; } }; @@ -1479,12 +1927,16 @@ pub const Opcode = enum(u16) { OpPtrEqual = 401, OpPtrNotEqual = 402, OpPtrDiff = 403, + OpColorAttachmentReadEXT = 4160, + OpDepthAttachmentReadEXT = 4161, + OpStencilAttachmentReadEXT = 4162, OpTerminateInvocation = 4416, OpSubgroupBallotKHR = 4421, OpSubgroupFirstInvocationKHR = 4422, OpSubgroupAllKHR = 4428, OpSubgroupAnyKHR = 4429, OpSubgroupAllEqualKHR = 4430, + OpGroupNonUniformRotateKHR = 4431, OpSubgroupReadInvocationKHR = 4432, OpTraceRayKHR = 4445, OpExecuteCallableKHR = 4446, @@ -1497,6 +1949,11 @@ pub const Opcode = enum(u16) { OpSDotAccSat = 4453, OpUDotAccSat = 4454, OpSUDotAccSat = 4455, + OpTypeCooperativeMatrixKHR = 4456, + OpCooperativeMatrixLoadKHR = 4457, + OpCooperativeMatrixStoreKHR = 4458, + OpCooperativeMatrixMulAddKHR = 4459, + OpCooperativeMatrixLengthKHR = 4460, OpTypeRayQueryKHR = 4472, OpRayQueryInitializeKHR = 4473, OpRayQueryTerminateKHR = 4474, @@ -1504,6 +1961,14 @@ pub const Opcode = enum(u16) { OpRayQueryConfirmIntersectionKHR = 4476, OpRayQueryProceedKHR = 4477, OpRayQueryGetIntersectionTypeKHR = 4479, + OpImageSampleWeightedQCOM = 4480, + OpImageBoxFilterQCOM = 4481, + OpImageBlockMatchSSDQCOM = 4482, + OpImageBlockMatchSADQCOM = 4483, + OpImageBlockMatchWindowSSDQCOM = 4500, + OpImageBlockMatchWindowSADQCOM = 4501, + OpImageBlockMatchGatherSSDQCOM = 4502, + OpImageBlockMatchGatherSADQCOM = 4503, OpGroupIAddNonUniformAMD = 5000, OpGroupFAddNonUniformAMD = 5001, OpGroupFMinNonUniformAMD = 5002, @@ -1515,15 +1980,58 @@ pub const Opcode = enum(u16) { OpFragmentMaskFetchAMD = 5011, OpFragmentFetchAMD = 5012, OpReadClockKHR = 5056, + OpFinalizeNodePayloadsAMDX = 5075, + OpFinishWritingNodePayloadAMDX = 5078, + OpInitializeNodePayloadsAMDX = 5090, + OpGroupNonUniformQuadAllKHR = 5110, + OpGroupNonUniformQuadAnyKHR = 5111, + OpHitObjectRecordHitMotionNV = 5249, + OpHitObjectRecordHitWithIndexMotionNV = 5250, + OpHitObjectRecordMissMotionNV = 5251, + OpHitObjectGetWorldToObjectNV = 5252, + OpHitObjectGetObjectToWorldNV = 5253, + OpHitObjectGetObjectRayDirectionNV = 5254, + OpHitObjectGetObjectRayOriginNV = 5255, + OpHitObjectTraceRayMotionNV = 5256, + OpHitObjectGetShaderRecordBufferHandleNV = 5257, + OpHitObjectGetShaderBindingTableRecordIndexNV = 5258, + OpHitObjectRecordEmptyNV = 5259, + OpHitObjectTraceRayNV = 5260, + OpHitObjectRecordHitNV = 5261, + OpHitObjectRecordHitWithIndexNV = 5262, + OpHitObjectRecordMissNV = 5263, + OpHitObjectExecuteShaderNV = 5264, + OpHitObjectGetCurrentTimeNV = 5265, + OpHitObjectGetAttributesNV = 5266, + OpHitObjectGetHitKindNV = 5267, + OpHitObjectGetPrimitiveIndexNV = 5268, + OpHitObjectGetGeometryIndexNV = 5269, + OpHitObjectGetInstanceIdNV = 5270, + OpHitObjectGetInstanceCustomIndexNV = 5271, + OpHitObjectGetWorldRayDirectionNV = 5272, + OpHitObjectGetWorldRayOriginNV = 5273, + OpHitObjectGetRayTMaxNV = 5274, + OpHitObjectGetRayTMinNV = 5275, + OpHitObjectIsEmptyNV = 5276, + OpHitObjectIsHitNV = 5277, + OpHitObjectIsMissNV = 5278, + OpReorderThreadWithHitObjectNV = 5279, + OpReorderThreadWithHintNV = 5280, + OpTypeHitObjectNV = 5281, OpImageSampleFootprintNV = 5283, + OpEmitMeshTasksEXT = 5294, + OpSetMeshOutputsEXT = 5295, OpGroupNonUniformPartitionNV = 5296, OpWritePackedPrimitiveIndices4x8NV = 5299, + OpFetchMicroTriangleVertexPositionNV = 5300, + OpFetchMicroTriangleVertexBarycentricNV = 5301, OpReportIntersectionKHR = 5334, OpIgnoreIntersectionNV = 5335, OpTerminateRayNV = 5336, OpTraceNV = 5337, OpTraceMotionNV = 5338, OpTraceRayMotionNV = 5339, + OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340, OpTypeAccelerationStructureKHR = 5341, OpExecuteCallableNV = 5344, OpTypeCooperativeMatrixNV = 5358, @@ -1542,6 +2050,7 @@ pub const Opcode = enum(u16) { OpConvertUToSampledImageNV = 5395, OpConvertSampledImageToUNV = 5396, OpSamplerImageAddressingModeNV = 5397, + OpRawAccessChainNV = 5398, OpSubgroupShuffleINTEL = 5571, OpSubgroupShuffleDownINTEL = 5572, OpSubgroupShuffleUpINTEL = 5573, @@ -1598,7 +2107,21 @@ pub const Opcode = enum(u16) { OpTypeStructContinuedINTEL = 6090, OpConstantCompositeContinuedINTEL = 6091, OpSpecConstantCompositeContinuedINTEL = 6092, - + OpCompositeConstructContinuedINTEL = 6096, + OpConvertFToBF16INTEL = 6116, + OpConvertBF16ToFINTEL = 6117, + OpControlBarrierArriveINTEL = 6142, + OpControlBarrierWaitINTEL = 6143, + OpGroupIMulKHR = 6401, + OpGroupFMulKHR = 6402, + OpGroupBitwiseAndKHR = 6403, + OpGroupBitwiseOrKHR = 6404, + OpGroupBitwiseXorKHR = 6405, + OpGroupLogicalAndKHR = 6406, + OpGroupLogicalOrKHR = 6407, + OpGroupLogicalXorKHR = 6408, + OpMaskedGatherINTEL = 6428, + OpMaskedScatterINTEL = 6429, pub const OpSDotKHR = Opcode.OpSDot; pub const OpUDotKHR = Opcode.OpUDot; pub const OpSUDotKHR = Opcode.OpSUDot; @@ -1957,12 +2480,16 @@ pub const Opcode = enum(u16) { .OpPtrEqual => struct { id_result_type: IdResultType, id_result: IdResult, operand_1: IdRef, operand_2: IdRef }, .OpPtrNotEqual => struct { id_result_type: IdResultType, id_result: IdResult, operand_1: IdRef, operand_2: IdRef }, .OpPtrDiff => struct { id_result_type: IdResultType, id_result: IdResult, operand_1: IdRef, operand_2: IdRef }, + .OpColorAttachmentReadEXT => struct { id_result_type: IdResultType, id_result: IdResult, attachment: IdRef, sample: ?IdRef = null }, + .OpDepthAttachmentReadEXT => struct { id_result_type: IdResultType, id_result: IdResult, sample: ?IdRef = null }, + .OpStencilAttachmentReadEXT => struct { id_result_type: IdResultType, id_result: IdResult, sample: ?IdRef = null }, .OpTerminateInvocation => void, .OpSubgroupBallotKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, .OpSubgroupFirstInvocationKHR => struct { id_result_type: IdResultType, id_result: IdResult, value: IdRef }, .OpSubgroupAllKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, .OpSubgroupAnyKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, .OpSubgroupAllEqualKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, + .OpGroupNonUniformRotateKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, value: IdRef, delta: IdRef, clustersize: ?IdRef = null }, .OpSubgroupReadInvocationKHR => struct { id_result_type: IdResultType, id_result: IdResult, value: IdRef, index: IdRef }, .OpTraceRayKHR => struct { accel: IdRef, ray_flags: IdRef, cull_mask: IdRef, sbt_offset: IdRef, sbt_stride: IdRef, miss_index: IdRef, ray_origin: IdRef, ray_tmin: IdRef, ray_direction: IdRef, ray_tmax: IdRef, payload: IdRef }, .OpExecuteCallableKHR => struct { sbt_index: IdRef, callable_data: IdRef }, @@ -1975,6 +2502,11 @@ pub const Opcode = enum(u16) { .OpSDotAccSat => struct { id_result_type: IdResultType, id_result: IdResult, vector_1: IdRef, vector_2: IdRef, accumulator: IdRef, packed_vector_format: ?PackedVectorFormat = null }, .OpUDotAccSat => struct { id_result_type: IdResultType, id_result: IdResult, vector_1: IdRef, vector_2: IdRef, accumulator: IdRef, packed_vector_format: ?PackedVectorFormat = null }, .OpSUDotAccSat => struct { id_result_type: IdResultType, id_result: IdResult, vector_1: IdRef, vector_2: IdRef, accumulator: IdRef, packed_vector_format: ?PackedVectorFormat = null }, + .OpTypeCooperativeMatrixKHR => struct { id_result: IdResult, component_type: IdRef, scope: IdScope, rows: IdRef, columns: IdRef, use: IdRef }, + .OpCooperativeMatrixLoadKHR => struct { id_result_type: IdResultType, id_result: IdResult, pointer: IdRef, memorylayout: IdRef, stride: ?IdRef = null, memory_operand: ?MemoryAccess.Extended = null }, + .OpCooperativeMatrixStoreKHR => struct { pointer: IdRef, object: IdRef, memorylayout: IdRef, stride: ?IdRef = null, memory_operand: ?MemoryAccess.Extended = null }, + .OpCooperativeMatrixMulAddKHR => struct { id_result_type: IdResultType, id_result: IdResult, a: IdRef, b: IdRef, c: IdRef, cooperative_matrix_operands: ?CooperativeMatrixOperands = null }, + .OpCooperativeMatrixLengthKHR => struct { id_result_type: IdResultType, id_result: IdResult, type: IdRef }, .OpTypeRayQueryKHR => struct { id_result: IdResult }, .OpRayQueryInitializeKHR => struct { rayquery: IdRef, accel: IdRef, rayflags: IdRef, cullmask: IdRef, rayorigin: IdRef, raytmin: IdRef, raydirection: IdRef, raytmax: IdRef }, .OpRayQueryTerminateKHR => struct { rayquery: IdRef }, @@ -1982,6 +2514,14 @@ pub const Opcode = enum(u16) { .OpRayQueryConfirmIntersectionKHR => struct { rayquery: IdRef }, .OpRayQueryProceedKHR => struct { id_result_type: IdResultType, id_result: IdResult, rayquery: IdRef }, .OpRayQueryGetIntersectionTypeKHR => struct { id_result_type: IdResultType, id_result: IdResult, rayquery: IdRef, intersection: IdRef }, + .OpImageSampleWeightedQCOM => struct { id_result_type: IdResultType, id_result: IdResult, texture: IdRef, coordinates: IdRef, weights: IdRef }, + .OpImageBoxFilterQCOM => struct { id_result_type: IdResultType, id_result: IdResult, texture: IdRef, coordinates: IdRef, box_size: IdRef }, + .OpImageBlockMatchSSDQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target: IdRef, target_coordinates: IdRef, reference: IdRef, reference_coordinates: IdRef, block_size: IdRef }, + .OpImageBlockMatchSADQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target: IdRef, target_coordinates: IdRef, reference: IdRef, reference_coordinates: IdRef, block_size: IdRef }, + .OpImageBlockMatchWindowSSDQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target_sampled_image: IdRef, target_coordinates: IdRef, reference_sampled_image: IdRef, reference_coordinates: IdRef, block_size: IdRef }, + .OpImageBlockMatchWindowSADQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target_sampled_image: IdRef, target_coordinates: IdRef, reference_sampled_image: IdRef, reference_coordinates: IdRef, block_size: IdRef }, + .OpImageBlockMatchGatherSSDQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target_sampled_image: IdRef, target_coordinates: IdRef, reference_sampled_image: IdRef, reference_coordinates: IdRef, block_size: IdRef }, + .OpImageBlockMatchGatherSADQCOM => struct { id_result_type: IdResultType, id_result: IdResult, target_sampled_image: IdRef, target_coordinates: IdRef, reference_sampled_image: IdRef, reference_coordinates: IdRef, block_size: IdRef }, .OpGroupIAddNonUniformAMD => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, .OpGroupFAddNonUniformAMD => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, .OpGroupFMinNonUniformAMD => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, @@ -1993,15 +2533,58 @@ pub const Opcode = enum(u16) { .OpFragmentMaskFetchAMD => struct { id_result_type: IdResultType, id_result: IdResult, image: IdRef, coordinate: IdRef }, .OpFragmentFetchAMD => struct { id_result_type: IdResultType, id_result: IdResult, image: IdRef, coordinate: IdRef, fragment_index: IdRef }, .OpReadClockKHR => struct { id_result_type: IdResultType, id_result: IdResult, scope: IdScope }, + .OpFinalizeNodePayloadsAMDX => struct { payload_array: IdRef }, + .OpFinishWritingNodePayloadAMDX => struct { id_result_type: IdResultType, id_result: IdResult, payload: IdRef }, + .OpInitializeNodePayloadsAMDX => struct { payload_array: IdRef, visibility: IdScope, payload_count: IdRef, node_index: IdRef }, + .OpGroupNonUniformQuadAllKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, + .OpGroupNonUniformQuadAnyKHR => struct { id_result_type: IdResultType, id_result: IdResult, predicate: IdRef }, + .OpHitObjectRecordHitMotionNV => struct { hit_object: IdRef, acceleration_structure: IdRef, instanceid: IdRef, primitiveid: IdRef, geometryindex: IdRef, hit_kind: IdRef, sbt_record_offset: IdRef, sbt_record_stride: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, current_time: IdRef, hitobject_attributes: IdRef }, + .OpHitObjectRecordHitWithIndexMotionNV => struct { hit_object: IdRef, acceleration_structure: IdRef, instanceid: IdRef, primitiveid: IdRef, geometryindex: IdRef, hit_kind: IdRef, sbt_record_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, current_time: IdRef, hitobject_attributes: IdRef }, + .OpHitObjectRecordMissMotionNV => struct { hit_object: IdRef, sbt_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, current_time: IdRef }, + .OpHitObjectGetWorldToObjectNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetObjectToWorldNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetObjectRayDirectionNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetObjectRayOriginNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectTraceRayMotionNV => struct { hit_object: IdRef, acceleration_structure: IdRef, rayflags: IdRef, cullmask: IdRef, sbt_record_offset: IdRef, sbt_record_stride: IdRef, miss_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, time: IdRef, payload: IdRef }, + .OpHitObjectGetShaderRecordBufferHandleNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetShaderBindingTableRecordIndexNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectRecordEmptyNV => struct { hit_object: IdRef }, + .OpHitObjectTraceRayNV => struct { hit_object: IdRef, acceleration_structure: IdRef, rayflags: IdRef, cullmask: IdRef, sbt_record_offset: IdRef, sbt_record_stride: IdRef, miss_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, payload: IdRef }, + .OpHitObjectRecordHitNV => struct { hit_object: IdRef, acceleration_structure: IdRef, instanceid: IdRef, primitiveid: IdRef, geometryindex: IdRef, hit_kind: IdRef, sbt_record_offset: IdRef, sbt_record_stride: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, hitobject_attributes: IdRef }, + .OpHitObjectRecordHitWithIndexNV => struct { hit_object: IdRef, acceleration_structure: IdRef, instanceid: IdRef, primitiveid: IdRef, geometryindex: IdRef, hit_kind: IdRef, sbt_record_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef, hitobject_attributes: IdRef }, + .OpHitObjectRecordMissNV => struct { hit_object: IdRef, sbt_index: IdRef, origin: IdRef, tmin: IdRef, direction: IdRef, tmax: IdRef }, + .OpHitObjectExecuteShaderNV => struct { hit_object: IdRef, payload: IdRef }, + .OpHitObjectGetCurrentTimeNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetAttributesNV => struct { hit_object: IdRef, hit_object_attribute: IdRef }, + .OpHitObjectGetHitKindNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetPrimitiveIndexNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetGeometryIndexNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetInstanceIdNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetInstanceCustomIndexNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetWorldRayDirectionNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetWorldRayOriginNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetRayTMaxNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectGetRayTMinNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectIsEmptyNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectIsHitNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpHitObjectIsMissNV => struct { id_result_type: IdResultType, id_result: IdResult, hit_object: IdRef }, + .OpReorderThreadWithHitObjectNV => struct { hit_object: IdRef, hint: ?IdRef = null, bits: ?IdRef = null }, + .OpReorderThreadWithHintNV => struct { hint: IdRef, bits: IdRef }, + .OpTypeHitObjectNV => struct { id_result: IdResult }, .OpImageSampleFootprintNV => struct { id_result_type: IdResultType, id_result: IdResult, sampled_image: IdRef, coordinate: IdRef, granularity: IdRef, coarse: IdRef, image_operands: ?ImageOperands.Extended = null }, + .OpEmitMeshTasksEXT => struct { group_count_x: IdRef, group_count_y: IdRef, group_count_z: IdRef, payload: ?IdRef = null }, + .OpSetMeshOutputsEXT => struct { vertex_count: IdRef, primitive_count: IdRef }, .OpGroupNonUniformPartitionNV => struct { id_result_type: IdResultType, id_result: IdResult, value: IdRef }, .OpWritePackedPrimitiveIndices4x8NV => struct { index_offset: IdRef, packed_indices: IdRef }, + .OpFetchMicroTriangleVertexPositionNV => struct { id_result_type: IdResultType, id_result: IdResult, accel: IdRef, instance_id: IdRef, geometry_index: IdRef, primitive_index: IdRef, barycentric: IdRef }, + .OpFetchMicroTriangleVertexBarycentricNV => struct { id_result_type: IdResultType, id_result: IdResult, accel: IdRef, instance_id: IdRef, geometry_index: IdRef, primitive_index: IdRef, barycentric: IdRef }, .OpReportIntersectionKHR => struct { id_result_type: IdResultType, id_result: IdResult, hit: IdRef, hitkind: IdRef }, .OpIgnoreIntersectionNV => void, .OpTerminateRayNV => void, .OpTraceNV => struct { accel: IdRef, ray_flags: IdRef, cull_mask: IdRef, sbt_offset: IdRef, sbt_stride: IdRef, miss_index: IdRef, ray_origin: IdRef, ray_tmin: IdRef, ray_direction: IdRef, ray_tmax: IdRef, payloadid: IdRef }, .OpTraceMotionNV => struct { accel: IdRef, ray_flags: IdRef, cull_mask: IdRef, sbt_offset: IdRef, sbt_stride: IdRef, miss_index: IdRef, ray_origin: IdRef, ray_tmin: IdRef, ray_direction: IdRef, ray_tmax: IdRef, time: IdRef, payloadid: IdRef }, .OpTraceRayMotionNV => struct { accel: IdRef, ray_flags: IdRef, cull_mask: IdRef, sbt_offset: IdRef, sbt_stride: IdRef, miss_index: IdRef, ray_origin: IdRef, ray_tmin: IdRef, ray_direction: IdRef, ray_tmax: IdRef, time: IdRef, payload: IdRef }, + .OpRayQueryGetIntersectionTriangleVertexPositionsKHR => struct { id_result_type: IdResultType, id_result: IdResult, rayquery: IdRef, intersection: IdRef }, .OpTypeAccelerationStructureKHR => struct { id_result: IdResult }, .OpExecuteCallableNV => struct { sbt_index: IdRef, callable_dataid: IdRef }, .OpTypeCooperativeMatrixNV => struct { id_result: IdResult, component_type: IdRef, execution: IdScope, rows: IdRef, columns: IdRef }, @@ -2020,6 +2603,7 @@ pub const Opcode = enum(u16) { .OpConvertUToSampledImageNV => struct { id_result_type: IdResultType, id_result: IdResult, operand: IdRef }, .OpConvertSampledImageToUNV => struct { id_result_type: IdResultType, id_result: IdResult, operand: IdRef }, .OpSamplerImageAddressingModeNV => struct { bit_width: LiteralInteger }, + .OpRawAccessChainNV => struct { id_result_type: IdResultType, id_result: IdResult, base: IdRef, byte_stride: IdRef, element_index: IdRef, byte_offset: IdRef, raw_access_chain_operands: ?RawAccessChainOperands = null }, .OpSubgroupShuffleINTEL => struct { id_result_type: IdResultType, id_result: IdResult, data: IdRef, invocationid: IdRef }, .OpSubgroupShuffleDownINTEL => struct { id_result_type: IdResultType, id_result: IdResult, current: IdRef, next: IdRef, delta: IdRef }, .OpSubgroupShuffleUpINTEL => struct { id_result_type: IdResultType, id_result: IdResult, previous: IdRef, current: IdRef, delta: IdRef }, @@ -2076,2699 +2660,24 @@ pub const Opcode = enum(u16) { .OpTypeStructContinuedINTEL => struct { id_ref: []const IdRef = &.{} }, .OpConstantCompositeContinuedINTEL => struct { constituents: []const IdRef = &.{} }, .OpSpecConstantCompositeContinuedINTEL => struct { constituents: []const IdRef = &.{} }, + .OpCompositeConstructContinuedINTEL => struct { id_result_type: IdResultType, id_result: IdResult, constituents: []const IdRef = &.{} }, + .OpConvertFToBF16INTEL => struct { id_result_type: IdResultType, id_result: IdResult, float_value: IdRef }, + .OpConvertBF16ToFINTEL => struct { id_result_type: IdResultType, id_result: IdResult, bfloat16_value: IdRef }, + .OpControlBarrierArriveINTEL => struct { execution: IdScope, memory: IdScope, semantics: IdMemorySemantics }, + .OpControlBarrierWaitINTEL => struct { execution: IdScope, memory: IdScope, semantics: IdMemorySemantics }, + .OpGroupIMulKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupFMulKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupBitwiseAndKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupBitwiseOrKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupBitwiseXorKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupLogicalAndKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupLogicalOrKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpGroupLogicalXorKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, operation: GroupOperation, x: IdRef }, + .OpMaskedGatherINTEL => struct { id_result_type: IdResultType, id_result: IdResult, ptrvector: IdRef, alignment: LiteralInteger, mask: IdRef, fillempty: IdRef }, + .OpMaskedScatterINTEL => struct { inputvector: IdRef, ptrvector: IdRef, alignment: LiteralInteger, mask: IdRef }, }; } - pub fn operands(self: Opcode) []const Operand { - return switch (self) { - .OpNop => &[_]Operand{}, - .OpUndef => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpSourceContinued => &[_]Operand{ - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpSource => &[_]Operand{ - .{ .kind = .SourceLanguage, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - .{ .kind = .LiteralString, .quantifier = .optional }, - }, - .OpSourceExtension => &[_]Operand{ - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpName => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpMemberName => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpString => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpLine => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpExtension => &[_]Operand{ - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpExtInstImport => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpExtInst => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralExtInstInteger, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpMemoryModel => &[_]Operand{ - .{ .kind = .AddressingModel, .quantifier = .required }, - .{ .kind = .MemoryModel, .quantifier = .required }, - }, - .OpEntryPoint => &[_]Operand{ - .{ .kind = .ExecutionModel, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpExecutionMode => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ExecutionMode, .quantifier = .required }, - }, - .OpCapability => &[_]Operand{ - .{ .kind = .Capability, .quantifier = .required }, - }, - .OpTypeVoid => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeBool => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeInt => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpTypeFloat => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpTypeVector => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpTypeMatrix => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpTypeImage => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .Dim, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .ImageFormat, .quantifier = .required }, - .{ .kind = .AccessQualifier, .quantifier = .optional }, - }, - .OpTypeSampler => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeSampledImage => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeArray => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeRuntimeArray => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeStruct => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpTypeOpaque => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpTypePointer => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .StorageClass, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeFunction => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpTypeEvent => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeDeviceEvent => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeReserveId => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypeQueue => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpTypePipe => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .AccessQualifier, .quantifier = .required }, - }, - .OpTypeForwardPointer => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .StorageClass, .quantifier = .required }, - }, - .OpConstantTrue => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpConstantFalse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpConstant => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralContextDependentNumber, .quantifier = .required }, - }, - .OpConstantComposite => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpConstantSampler => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .SamplerAddressingMode, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .SamplerFilterMode, .quantifier = .required }, - }, - .OpConstantNull => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpSpecConstantTrue => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpSpecConstantFalse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpSpecConstant => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralContextDependentNumber, .quantifier = .required }, - }, - .OpSpecConstantComposite => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpSpecConstantOp => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralSpecConstantOpInteger, .quantifier = .required }, - }, - .OpFunction => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .FunctionControl, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFunctionParameter => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpFunctionEnd => &[_]Operand{}, - .OpFunctionCall => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpVariable => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .StorageClass, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpImageTexelPointer => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLoad => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpStore => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpCopyMemory => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpCopyMemorySized => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpAccessChain => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpInBoundsAccessChain => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpPtrAccessChain => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpArrayLength => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpGenericPtrMemSemantics => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpInBoundsPtrAccessChain => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpDecorate => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .Decoration, .quantifier = .required }, - }, - .OpMemberDecorate => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .Decoration, .quantifier = .required }, - }, - .OpDecorationGroup => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpGroupDecorate => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpGroupMemberDecorate => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PairIdRefLiteralInteger, .quantifier = .variadic }, - }, - .OpVectorExtractDynamic => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpVectorInsertDynamic => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpVectorShuffle => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .variadic }, - }, - .OpCompositeConstruct => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpCompositeExtract => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .variadic }, - }, - .OpCompositeInsert => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .variadic }, - }, - .OpCopyObject => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTranspose => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSampledImage => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageSampleImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSampleExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSampleDrefImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSampleDrefExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSampleProjImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSampleProjExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSampleProjDrefImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSampleProjDrefExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageFetch => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageGather => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageDrefGather => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageRead => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageWrite => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImage => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQueryFormat => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQueryOrder => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQuerySizeLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQuerySize => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQueryLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQueryLevels => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageQuerySamples => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertFToU => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertFToS => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertSToF => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertUToF => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUConvert => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSConvert => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFConvert => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpQuantizeToF16 => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertPtrToU => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSatConvertSToU => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSatConvertUToS => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertUToPtr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpPtrCastToGeneric => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGenericCastToPtr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGenericCastToPtrExplicit => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .StorageClass, .quantifier = .required }, - }, - .OpBitcast => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSNegate => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFNegate => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpISub => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFSub => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIMul => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFMul => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUDiv => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSDiv => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFDiv => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUMod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSRem => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSMod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFRem => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFMod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpVectorTimesScalar => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpMatrixTimesScalar => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpVectorTimesMatrix => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpMatrixTimesVector => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpMatrixTimesMatrix => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpOuterProduct => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIAddCarry => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpISubBorrow => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUMulExtended => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSMulExtended => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAny => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAll => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIsNan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIsInf => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIsFinite => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIsNormal => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSignBitSet => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLessOrGreater => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpOrdered => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUnordered => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLogicalEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLogicalNotEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLogicalOr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLogicalAnd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpLogicalNot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSelect => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpINotEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUGreaterThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSGreaterThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUGreaterThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSGreaterThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpULessThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSLessThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpULessThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSLessThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdNotEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordNotEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdLessThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordLessThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdGreaterThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordGreaterThan => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdLessThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordLessThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFOrdGreaterThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFUnordGreaterThanEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpShiftRightLogical => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpShiftRightArithmetic => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpShiftLeftLogical => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitwiseOr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitwiseXor => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitwiseAnd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpNot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitFieldInsert => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitFieldSExtract => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitFieldUExtract => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitReverse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBitCount => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdx => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdy => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFwidth => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdxFine => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdyFine => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFwidthFine => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdxCoarse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDPdyCoarse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFwidthCoarse => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpEmitVertex => &[_]Operand{}, - .OpEndPrimitive => &[_]Operand{}, - .OpEmitStreamVertex => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpEndStreamPrimitive => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpControlBarrier => &[_]Operand{ - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpMemoryBarrier => &[_]Operand{ - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpAtomicLoad => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpAtomicStore => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicExchange => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicCompareExchange => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicCompareExchangeWeak => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicIIncrement => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpAtomicIDecrement => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpAtomicIAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicISub => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicSMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicUMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicSMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicUMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicAnd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicOr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicXor => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpPhi => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, - }, - .OpLoopMerge => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LoopControl, .quantifier = .required }, - }, - .OpSelectionMerge => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .SelectionControl, .quantifier = .required }, - }, - .OpLabel => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpBranch => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBranchConditional => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .variadic }, - }, - .OpSwitch => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PairLiteralIntegerIdRef, .quantifier = .variadic }, - }, - .OpKill => &[_]Operand{}, - .OpReturn => &[_]Operand{}, - .OpReturnValue => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUnreachable => &[_]Operand{}, - .OpLifetimeStart => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpLifetimeStop => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpGroupAsyncCopy => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupWaitEvents => &[_]Operand{ - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupAll => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupAny => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupBroadcast => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupIAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupUMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupSMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupUMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupSMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReadPipe => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpWritePipe => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReservedReadPipe => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReservedWritePipe => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReserveReadPipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReserveWritePipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCommitReadPipe => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCommitWritePipe => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIsValidReserveId => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetNumPipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetMaxPipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupReserveReadPipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupReserveWritePipePackets => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupCommitReadPipe => &[_]Operand{ - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupCommitWritePipe => &[_]Operand{ - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpEnqueueMarker => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpEnqueueKernel => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpGetKernelNDrangeSubGroupCount => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetKernelNDrangeMaxSubGroupSize => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetKernelWorkGroupSize => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetKernelPreferredWorkGroupSizeMultiple => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRetainEvent => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReleaseEvent => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCreateUserEvent => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpIsValidEvent => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSetUserEventStatus => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCaptureEventProfilingInfo => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetDefaultQueue => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpBuildNDRange => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpImageSparseSampleImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseSampleExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSparseSampleDrefImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseSampleDrefExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSparseSampleProjImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseSampleProjExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSparseSampleProjDrefImplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseSampleProjDrefExplicitLod => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .required }, - }, - .OpImageSparseFetch => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseGather => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseDrefGather => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpImageSparseTexelsResident => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpNoLine => &[_]Operand{}, - .OpAtomicFlagTestAndSet => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpAtomicFlagClear => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpImageSparseRead => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpSizeOf => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypePipeStorage => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpConstantPipeStorage => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpCreatePipeFromPipeStorage => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetKernelLocalSizeForSubgroupCount => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGetKernelMaxNumSubgroups => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeNamedBarrier => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpNamedBarrierInitialize => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpMemoryNamedBarrier => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - }, - .OpModuleProcessed => &[_]Operand{ - .{ .kind = .LiteralString, .quantifier = .required }, - }, - .OpExecutionModeId => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ExecutionMode, .quantifier = .required }, - }, - .OpDecorateId => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .Decoration, .quantifier = .required }, - }, - .OpGroupNonUniformElect => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - }, - .OpGroupNonUniformAll => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformAny => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformAllEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBroadcast => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBroadcastFirst => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBallot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformInverseBallot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBallotBitExtract => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBallotBitCount => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBallotFindLSB => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformBallotFindMSB => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformShuffle => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformShuffleXor => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformShuffleUp => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformShuffleDown => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformIAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformFAdd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformIMul => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformFMul => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformSMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformUMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformFMin => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformSMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformUMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformFMax => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformBitwiseAnd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformBitwiseOr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformBitwiseXor => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformLogicalAnd => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformLogicalOr => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformLogicalXor => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .optional }, - }, - .OpGroupNonUniformQuadBroadcast => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupNonUniformQuadSwap => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCopyLogical => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpPtrEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpPtrNotEqual => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpPtrDiff => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTerminateInvocation => &[_]Operand{}, - .OpSubgroupBallotKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupFirstInvocationKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupAllKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupAnyKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupAllEqualKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupReadInvocationKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTraceRayKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpExecuteCallableKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertUToAccelerationStructureKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIgnoreIntersectionKHR => &[_]Operand{}, - .OpTerminateRayKHR => &[_]Operand{}, - .OpSDot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpUDot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpSUDot => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpSDotAccSat => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpUDotAccSat => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpSUDotAccSat => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .PackedVectorFormat, .quantifier = .optional }, - }, - .OpTypeRayQueryKHR => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpRayQueryInitializeKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryTerminateKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGenerateIntersectionKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryConfirmIntersectionKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryProceedKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionTypeKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupIAddNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFAddNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFMinNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupUMinNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupSMinNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupFMaxNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupUMaxNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpGroupSMaxNonUniformAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .GroupOperation, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFragmentMaskFetchAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFragmentFetchAMD => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReadClockKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - }, - .OpImageSampleFootprintNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .ImageOperands, .quantifier = .optional }, - }, - .OpGroupNonUniformPartitionNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpWritePackedPrimitiveIndices4x8NV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpReportIntersectionKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIgnoreIntersectionNV => &[_]Operand{}, - .OpTerminateRayNV => &[_]Operand{}, - .OpTraceNV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTraceMotionNV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTraceRayMotionNV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeAccelerationStructureKHR => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpExecuteCallableNV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeCooperativeMatrixNV => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCooperativeMatrixLoadNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpCooperativeMatrixStoreNV => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .MemoryAccess, .quantifier = .optional }, - }, - .OpCooperativeMatrixMulAddNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpCooperativeMatrixLengthNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpBeginInvocationInterlockEXT => &[_]Operand{}, - .OpEndInvocationInterlockEXT => &[_]Operand{}, - .OpDemoteToHelperInvocation => &[_]Operand{}, - .OpIsHelperInvocationEXT => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - }, - .OpConvertUToImageNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertUToSamplerNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertImageToUNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertSamplerToUNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertUToSampledImageNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpConvertSampledImageToUNV => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSamplerImageAddressingModeNV => &[_]Operand{ - .{ .kind = .LiteralInteger, .quantifier = .required }, - }, - .OpSubgroupShuffleINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupShuffleDownINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupShuffleUpINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupShuffleXorINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupBlockReadINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupBlockWriteINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupImageBlockReadINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupImageBlockWriteINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupImageMediaBlockReadINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpSubgroupImageMediaBlockWriteINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUCountLeadingZerosINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUCountTrailingZerosINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAbsISubINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAbsUSubINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIAddSatINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUAddSatINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIAverageINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUAverageINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIAverageRoundedINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUAverageRoundedINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpISubSatINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUSubSatINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpIMul32x16INTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpUMul32x16INTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicFMinEXT => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicFMaxEXT => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAssumeTrueKHR => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpExpectKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpDecorateString => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .Decoration, .quantifier = .required }, - }, - .OpMemberDecorateString => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .LiteralInteger, .quantifier = .required }, - .{ .kind = .Decoration, .quantifier = .required }, - }, - .OpLoopControlINTEL => &[_]Operand{ - .{ .kind = .LiteralInteger, .quantifier = .variadic }, - }, - .OpReadPipeBlockingINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpWritePipeBlockingINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpFPGARegINTEL => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetRayTMinKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetRayFlagsKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionTKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionInstanceCustomIndexKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionInstanceIdKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionGeometryIndexKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionPrimitiveIndexKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionBarycentricsKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionFrontFaceKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionCandidateAABBOpaqueKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionObjectRayDirectionKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionObjectRayOriginKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetWorldRayDirectionKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetWorldRayOriginKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionObjectToWorldKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpRayQueryGetIntersectionWorldToObjectKHR => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpAtomicFAddEXT => &[_]Operand{ - .{ .kind = .IdResultType, .quantifier = .required }, - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - .{ .kind = .IdScope, .quantifier = .required }, - .{ .kind = .IdMemorySemantics, .quantifier = .required }, - .{ .kind = .IdRef, .quantifier = .required }, - }, - .OpTypeBufferSurfaceINTEL => &[_]Operand{ - .{ .kind = .IdResult, .quantifier = .required }, - .{ .kind = .AccessQualifier, .quantifier = .required }, - }, - .OpTypeStructContinuedINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpConstantCompositeContinuedINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - .OpSpecConstantCompositeContinuedINTEL => &[_]Operand{ - .{ .kind = .IdRef, .quantifier = .variadic }, - }, - }; - } - pub fn class(self: Opcode) Class { + pub fn class(self: Opcode) Class { return switch (self) { .OpNop => .Miscellaneous, .OpUndef => .Miscellaneous, @@ -5114,12 +3023,16 @@ pub const Opcode = enum(u16) { .OpPtrEqual => .Memory, .OpPtrNotEqual => .Memory, .OpPtrDiff => .Memory, + .OpColorAttachmentReadEXT => .Image, + .OpDepthAttachmentReadEXT => .Image, + .OpStencilAttachmentReadEXT => .Image, .OpTerminateInvocation => .ControlFlow, .OpSubgroupBallotKHR => .Group, .OpSubgroupFirstInvocationKHR => .Group, .OpSubgroupAllKHR => .Group, .OpSubgroupAnyKHR => .Group, .OpSubgroupAllEqualKHR => .Group, + .OpGroupNonUniformRotateKHR => .Group, .OpSubgroupReadInvocationKHR => .Group, .OpTraceRayKHR => .Reserved, .OpExecuteCallableKHR => .Reserved, @@ -5132,13 +3045,26 @@ pub const Opcode = enum(u16) { .OpSDotAccSat => .Arithmetic, .OpUDotAccSat => .Arithmetic, .OpSUDotAccSat => .Arithmetic, - .OpTypeRayQueryKHR => .Reserved, + .OpTypeCooperativeMatrixKHR => .TypeDeclaration, + .OpCooperativeMatrixLoadKHR => .Memory, + .OpCooperativeMatrixStoreKHR => .Memory, + .OpCooperativeMatrixMulAddKHR => .Arithmetic, + .OpCooperativeMatrixLengthKHR => .Miscellaneous, + .OpTypeRayQueryKHR => .TypeDeclaration, .OpRayQueryInitializeKHR => .Reserved, .OpRayQueryTerminateKHR => .Reserved, .OpRayQueryGenerateIntersectionKHR => .Reserved, .OpRayQueryConfirmIntersectionKHR => .Reserved, .OpRayQueryProceedKHR => .Reserved, .OpRayQueryGetIntersectionTypeKHR => .Reserved, + .OpImageSampleWeightedQCOM => .Image, + .OpImageBoxFilterQCOM => .Image, + .OpImageBlockMatchSSDQCOM => .Image, + .OpImageBlockMatchSADQCOM => .Image, + .OpImageBlockMatchWindowSSDQCOM => .Image, + .OpImageBlockMatchWindowSADQCOM => .Image, + .OpImageBlockMatchGatherSSDQCOM => .Image, + .OpImageBlockMatchGatherSADQCOM => .Image, .OpGroupIAddNonUniformAMD => .Group, .OpGroupFAddNonUniformAMD => .Group, .OpGroupFMinNonUniformAMD => .Group, @@ -5150,18 +3076,61 @@ pub const Opcode = enum(u16) { .OpFragmentMaskFetchAMD => .Reserved, .OpFragmentFetchAMD => .Reserved, .OpReadClockKHR => .Reserved, + .OpFinalizeNodePayloadsAMDX => .Reserved, + .OpFinishWritingNodePayloadAMDX => .Reserved, + .OpInitializeNodePayloadsAMDX => .Reserved, + .OpGroupNonUniformQuadAllKHR => .NonUniform, + .OpGroupNonUniformQuadAnyKHR => .NonUniform, + .OpHitObjectRecordHitMotionNV => .Reserved, + .OpHitObjectRecordHitWithIndexMotionNV => .Reserved, + .OpHitObjectRecordMissMotionNV => .Reserved, + .OpHitObjectGetWorldToObjectNV => .Reserved, + .OpHitObjectGetObjectToWorldNV => .Reserved, + .OpHitObjectGetObjectRayDirectionNV => .Reserved, + .OpHitObjectGetObjectRayOriginNV => .Reserved, + .OpHitObjectTraceRayMotionNV => .Reserved, + .OpHitObjectGetShaderRecordBufferHandleNV => .Reserved, + .OpHitObjectGetShaderBindingTableRecordIndexNV => .Reserved, + .OpHitObjectRecordEmptyNV => .Reserved, + .OpHitObjectTraceRayNV => .Reserved, + .OpHitObjectRecordHitNV => .Reserved, + .OpHitObjectRecordHitWithIndexNV => .Reserved, + .OpHitObjectRecordMissNV => .Reserved, + .OpHitObjectExecuteShaderNV => .Reserved, + .OpHitObjectGetCurrentTimeNV => .Reserved, + .OpHitObjectGetAttributesNV => .Reserved, + .OpHitObjectGetHitKindNV => .Reserved, + .OpHitObjectGetPrimitiveIndexNV => .Reserved, + .OpHitObjectGetGeometryIndexNV => .Reserved, + .OpHitObjectGetInstanceIdNV => .Reserved, + .OpHitObjectGetInstanceCustomIndexNV => .Reserved, + .OpHitObjectGetWorldRayDirectionNV => .Reserved, + .OpHitObjectGetWorldRayOriginNV => .Reserved, + .OpHitObjectGetRayTMaxNV => .Reserved, + .OpHitObjectGetRayTMinNV => .Reserved, + .OpHitObjectIsEmptyNV => .Reserved, + .OpHitObjectIsHitNV => .Reserved, + .OpHitObjectIsMissNV => .Reserved, + .OpReorderThreadWithHitObjectNV => .Reserved, + .OpReorderThreadWithHintNV => .Reserved, + .OpTypeHitObjectNV => .TypeDeclaration, .OpImageSampleFootprintNV => .Image, + .OpEmitMeshTasksEXT => .Reserved, + .OpSetMeshOutputsEXT => .Reserved, .OpGroupNonUniformPartitionNV => .NonUniform, .OpWritePackedPrimitiveIndices4x8NV => .Reserved, + .OpFetchMicroTriangleVertexPositionNV => .Reserved, + .OpFetchMicroTriangleVertexBarycentricNV => .Reserved, .OpReportIntersectionKHR => .Reserved, .OpIgnoreIntersectionNV => .Reserved, .OpTerminateRayNV => .Reserved, .OpTraceNV => .Reserved, .OpTraceMotionNV => .Reserved, .OpTraceRayMotionNV => .Reserved, - .OpTypeAccelerationStructureKHR => .Reserved, + .OpRayQueryGetIntersectionTriangleVertexPositionsKHR => .Reserved, + .OpTypeAccelerationStructureKHR => .TypeDeclaration, .OpExecuteCallableNV => .Reserved, - .OpTypeCooperativeMatrixNV => .Reserved, + .OpTypeCooperativeMatrixNV => .TypeDeclaration, .OpCooperativeMatrixLoadNV => .Reserved, .OpCooperativeMatrixStoreNV => .Reserved, .OpCooperativeMatrixMulAddNV => .Reserved, @@ -5177,6 +3146,7 @@ pub const Opcode = enum(u16) { .OpConvertUToSampledImageNV => .Reserved, .OpConvertSampledImageToUNV => .Reserved, .OpSamplerImageAddressingModeNV => .Reserved, + .OpRawAccessChainNV => .Memory, .OpSubgroupShuffleINTEL => .Group, .OpSubgroupShuffleDownINTEL => .Group, .OpSubgroupShuffleUpINTEL => .Group, @@ -5233,6 +3203,21 @@ pub const Opcode = enum(u16) { .OpTypeStructContinuedINTEL => .TypeDeclaration, .OpConstantCompositeContinuedINTEL => .ConstantCreation, .OpSpecConstantCompositeContinuedINTEL => .ConstantCreation, + .OpCompositeConstructContinuedINTEL => .Composite, + .OpConvertFToBF16INTEL => .Conversion, + .OpConvertBF16ToFINTEL => .Conversion, + .OpControlBarrierArriveINTEL => .Barrier, + .OpControlBarrierWaitINTEL => .Barrier, + .OpGroupIMulKHR => .Group, + .OpGroupFMulKHR => .Group, + .OpGroupBitwiseAndKHR => .Group, + .OpGroupBitwiseOrKHR => .Group, + .OpGroupBitwiseXorKHR => .Group, + .OpGroupLogicalAndKHR => .Group, + .OpGroupLogicalOrKHR => .Group, + .OpGroupLogicalXorKHR => .Group, + .OpMaskedGatherINTEL => .Memory, + .OpMaskedScatterINTEL => .Memory, }; } }; @@ -5327,9 +3312,9 @@ pub const FPFastMathMode = packed struct { _reserved_bit_13: bool = false, _reserved_bit_14: bool = false, _reserved_bit_15: bool = false, - AllowContractFastINTEL: bool = false, - AllowReassocINTEL: bool = false, - _reserved_bit_18: bool = false, + AllowContract: bool = false, + AllowReassoc: bool = false, + AllowTransform: bool = false, _reserved_bit_19: bool = false, _reserved_bit_20: bool = false, _reserved_bit_21: bool = false, @@ -5343,6 +3328,9 @@ pub const FPFastMathMode = packed struct { _reserved_bit_29: bool = false, _reserved_bit_30: bool = false, _reserved_bit_31: bool = false, + + pub const AllowContractFastINTEL: FPFastMathMode = .{ .AllowContract = true }; + pub const AllowReassocINTEL: FPFastMathMode = .{ .AllowReassoc = true }; }; pub const SelectionControl = packed struct { Flatten: bool = false, @@ -5403,8 +3391,8 @@ pub const LoopControl = packed struct { MaxInterleavingINTEL: bool = false, SpeculatedIterationsINTEL: bool = false, NoFusionINTEL: bool = false, - _reserved_bit_24: bool = false, - _reserved_bit_25: bool = false, + LoopCountINTEL: bool = false, + MaxReinvocationDelayINTEL: bool = false, _reserved_bit_26: bool = false, _reserved_bit_27: bool = false, _reserved_bit_28: bool = false, @@ -5436,9 +3424,9 @@ pub const LoopControl = packed struct { LoopCoalesceINTEL: ?struct { literal_integer: LiteralInteger } = null, MaxInterleavingINTEL: ?struct { literal_integer: LiteralInteger } = null, SpeculatedIterationsINTEL: ?struct { literal_integer: LiteralInteger } = null, - NoFusionINTEL: ?struct { literal_integer: LiteralInteger } = null, - _reserved_bit_24: bool = false, - _reserved_bit_25: bool = false, + NoFusionINTEL: bool = false, + LoopCountINTEL: ?struct { literal_integer: LiteralInteger } = null, + MaxReinvocationDelayINTEL: ?struct { literal_integer: LiteralInteger } = null, _reserved_bit_26: bool = false, _reserved_bit_27: bool = false, _reserved_bit_28: bool = false, @@ -5536,8 +3524,8 @@ pub const MemoryAccess = packed struct { _reserved_bit_13: bool = false, _reserved_bit_14: bool = false, _reserved_bit_15: bool = false, - _reserved_bit_16: bool = false, - _reserved_bit_17: bool = false, + AliasScopeINTELMask: bool = false, + NoAliasINTELMask: bool = false, _reserved_bit_18: bool = false, _reserved_bit_19: bool = false, _reserved_bit_20: bool = false, @@ -5574,8 +3562,8 @@ pub const MemoryAccess = packed struct { _reserved_bit_13: bool = false, _reserved_bit_14: bool = false, _reserved_bit_15: bool = false, - _reserved_bit_16: bool = false, - _reserved_bit_17: bool = false, + AliasScopeINTELMask: ?struct { id_ref: IdRef } = null, + NoAliasINTELMask: ?struct { id_ref: IdRef } = null, _reserved_bit_18: bool = false, _reserved_bit_19: bool = false, _reserved_bit_20: bool = false, @@ -5637,7 +3625,7 @@ pub const RayFlags = packed struct { CullNoOpaqueKHR: bool = false, SkipTrianglesKHR: bool = false, SkipAABBsKHR: bool = false, - _reserved_bit_10: bool = false, + ForceOpacityMicromap2StateEXT: bool = false, _reserved_bit_11: bool = false, _reserved_bit_12: bool = false, _reserved_bit_13: bool = false, @@ -5694,6 +3682,40 @@ pub const FragmentShadingRate = packed struct { _reserved_bit_30: bool = false, _reserved_bit_31: bool = false, }; +pub const RawAccessChainOperands = packed struct { + RobustnessPerComponentNV: bool = false, + RobustnessPerElementNV: bool = false, + _reserved_bit_2: bool = false, + _reserved_bit_3: bool = false, + _reserved_bit_4: bool = false, + _reserved_bit_5: bool = false, + _reserved_bit_6: bool = false, + _reserved_bit_7: bool = false, + _reserved_bit_8: bool = false, + _reserved_bit_9: bool = false, + _reserved_bit_10: bool = false, + _reserved_bit_11: bool = false, + _reserved_bit_12: bool = false, + _reserved_bit_13: bool = false, + _reserved_bit_14: bool = false, + _reserved_bit_15: bool = false, + _reserved_bit_16: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; pub const SourceLanguage = enum(u32) { Unknown = 0, ESSL = 1, @@ -5702,6 +3724,12 @@ pub const SourceLanguage = enum(u32) { OpenCL_CPP = 4, HLSL = 5, CPP_for_OpenCL = 6, + SYCL = 7, + HERO_C = 8, + NZSL = 9, + WGSL = 10, + Slang = 11, + Zig = 12, }; pub const ExecutionModel = enum(u32) { Vertex = 0, @@ -5719,6 +3747,8 @@ pub const ExecutionModel = enum(u32) { ClosestHitKHR = 5316, MissKHR = 5317, CallableKHR = 5318, + TaskEXT = 5364, + MeshEXT = 5365, pub const RayGenerationNV = ExecutionModel.RayGenerationKHR; pub const IntersectionNV = ExecutionModel.IntersectionKHR; @@ -5782,6 +3812,9 @@ pub const ExecutionMode = enum(u32) { SubgroupsPerWorkgroupId = 37, LocalSizeId = 38, LocalSizeHintId = 39, + NonCoherentColorAttachmentReadEXT = 4169, + NonCoherentDepthAttachmentReadEXT = 4170, + NonCoherentStencilAttachmentReadEXT = 4171, SubgroupUniformControlFlowKHR = 4421, PostDepthCoverage = 4446, DenormPreserve = 4459, @@ -5789,12 +3822,26 @@ pub const ExecutionMode = enum(u32) { SignedZeroInfNanPreserve = 4461, RoundingModeRTE = 4462, RoundingModeRTZ = 4463, + EarlyAndLateFragmentTestsAMD = 5017, StencilRefReplacingEXT = 5027, - OutputLinesNV = 5269, - OutputPrimitivesNV = 5270, + CoalescingAMDX = 5069, + MaxNodeRecursionAMDX = 5071, + StaticNumWorkgroupsAMDX = 5072, + ShaderIndexAMDX = 5073, + MaxNumWorkgroupsAMDX = 5077, + StencilRefUnchangedFrontAMD = 5079, + StencilRefGreaterFrontAMD = 5080, + StencilRefLessFrontAMD = 5081, + StencilRefUnchangedBackAMD = 5082, + StencilRefGreaterBackAMD = 5083, + StencilRefLessBackAMD = 5084, + QuadDerivativesKHR = 5088, + RequireFullQuadsKHR = 5089, + OutputLinesEXT = 5269, + OutputPrimitivesEXT = 5270, DerivativeGroupQuadsNV = 5289, DerivativeGroupLinearNV = 5290, - OutputTrianglesNV = 5298, + OutputTrianglesEXT = 5298, PixelInterlockOrderedEXT = 5366, PixelInterlockUnorderedEXT = 5367, SampleInterlockOrderedEXT = 5368, @@ -5811,6 +3858,18 @@ pub const ExecutionMode = enum(u32) { NoGlobalOffsetINTEL = 5895, NumSIMDWorkitemsINTEL = 5896, SchedulerTargetFmaxMhzINTEL = 5903, + MaximallyReconvergesKHR = 6023, + FPFastMathDefault = 6028, + StreamingInterfaceINTEL = 6154, + RegisterMapInterfaceINTEL = 6160, + NamedBarrierCountINTEL = 6417, + MaximumRegistersINTEL = 6461, + MaximumRegistersIdINTEL = 6462, + NamedMaximumRegistersINTEL = 6463, + + pub const OutputLinesNV = ExecutionMode.OutputLinesEXT; + pub const OutputPrimitivesNV = ExecutionMode.OutputPrimitivesEXT; + pub const OutputTrianglesNV = ExecutionMode.OutputTrianglesEXT; pub const Extended = union(ExecutionMode) { Invocations: struct { literal_integer: LiteralInteger }, @@ -5851,6 +3910,9 @@ pub const ExecutionMode = enum(u32) { SubgroupsPerWorkgroupId: struct { subgroups_per_workgroup: IdRef }, LocalSizeId: struct { x_size: IdRef, y_size: IdRef, z_size: IdRef }, LocalSizeHintId: struct { x_size_hint: IdRef, y_size_hint: IdRef, z_size_hint: IdRef }, + NonCoherentColorAttachmentReadEXT, + NonCoherentDepthAttachmentReadEXT, + NonCoherentStencilAttachmentReadEXT, SubgroupUniformControlFlowKHR, PostDepthCoverage, DenormPreserve: struct { target_width: LiteralInteger }, @@ -5858,12 +3920,26 @@ pub const ExecutionMode = enum(u32) { SignedZeroInfNanPreserve: struct { target_width: LiteralInteger }, RoundingModeRTE: struct { target_width: LiteralInteger }, RoundingModeRTZ: struct { target_width: LiteralInteger }, + EarlyAndLateFragmentTestsAMD, StencilRefReplacingEXT, - OutputLinesNV, - OutputPrimitivesNV: struct { primitive_count: LiteralInteger }, + CoalescingAMDX, + MaxNodeRecursionAMDX: struct { number_of_recursions: IdRef }, + StaticNumWorkgroupsAMDX: struct { x_size: IdRef, y_size: IdRef, z_size: IdRef }, + ShaderIndexAMDX: struct { shader_index: IdRef }, + MaxNumWorkgroupsAMDX: struct { x_size: IdRef, y_size: IdRef, z_size: IdRef }, + StencilRefUnchangedFrontAMD, + StencilRefGreaterFrontAMD, + StencilRefLessFrontAMD, + StencilRefUnchangedBackAMD, + StencilRefGreaterBackAMD, + StencilRefLessBackAMD, + QuadDerivativesKHR, + RequireFullQuadsKHR, + OutputLinesEXT, + OutputPrimitivesEXT: struct { primitive_count: LiteralInteger }, DerivativeGroupQuadsNV, DerivativeGroupLinearNV, - OutputTrianglesNV, + OutputTrianglesEXT, PixelInterlockOrderedEXT, PixelInterlockUnorderedEXT, SampleInterlockOrderedEXT, @@ -5880,6 +3956,14 @@ pub const ExecutionMode = enum(u32) { NoGlobalOffsetINTEL, NumSIMDWorkitemsINTEL: struct { literal_integer: LiteralInteger }, SchedulerTargetFmaxMhzINTEL: struct { literal_integer: LiteralInteger }, + MaximallyReconvergesKHR, + FPFastMathDefault: struct { target_type: IdRef, id_ref_1: IdRef }, + StreamingInterfaceINTEL: struct { stallfreereturn: LiteralInteger }, + RegisterMapInterfaceINTEL: struct { waitfordonewrite: LiteralInteger }, + NamedBarrierCountINTEL: struct { barrier_count: LiteralInteger }, + MaximumRegistersINTEL: struct { number_of_registers: LiteralInteger }, + MaximumRegistersIdINTEL: struct { number_of_registers: IdRef }, + NamedMaximumRegistersINTEL: struct { named_maximum_number_of_registers: NamedMaximumNumberOfRegisters }, }; }; pub const StorageClass = enum(u32) { @@ -5896,6 +3980,9 @@ pub const StorageClass = enum(u32) { AtomicCounter = 10, Image = 11, StorageBuffer = 12, + TileImageEXT = 4172, + NodePayloadAMDX = 5068, + NodeOutputPayloadAMDX = 5076, CallableDataKHR = 5328, IncomingCallableDataKHR = 5329, RayPayloadKHR = 5338, @@ -5903,6 +3990,8 @@ pub const StorageClass = enum(u32) { IncomingRayPayloadKHR = 5342, ShaderRecordBufferKHR = 5343, PhysicalStorageBuffer = 5349, + HitObjectAttributeNV = 5385, + TaskPayloadWorkgroupEXT = 5402, CodeSectionINTEL = 5605, DeviceOnlyINTEL = 5936, HostOnlyINTEL = 5937, @@ -5923,6 +4012,7 @@ pub const Dim = enum(u32) { Rect = 4, Buffer = 5, SubpassData = 6, + TileImageDataEXT = 4173, }; pub const SamplerAddressingMode = enum(u32) { None = 0, @@ -6019,6 +4109,8 @@ pub const ImageChannelDataType = enum(u32) { Float = 14, UnormInt24 = 15, UnormInt101010_2 = 16, + UnsignedIntRaw10EXT = 19, + UnsignedIntRaw12EXT = 20, }; pub const FPRoundingMode = enum(u32) { RTE = 0, @@ -6060,6 +4152,12 @@ pub const AccessQualifier = enum(u32) { WriteOnly = 1, ReadWrite = 2, }; +pub const HostAccessQualifier = enum(u32) { + NoneINTEL = 0, + ReadINTEL = 1, + WriteINTEL = 2, + ReadWriteINTEL = 3, +}; pub const FunctionParameterAttribute = enum(u32) { Zext = 0, Sext = 1, @@ -6069,6 +4167,7 @@ pub const FunctionParameterAttribute = enum(u32) { NoCapture = 5, NoWrite = 6, NoReadWrite = 7, + RuntimeAlignedINTEL = 5940, }; pub const Decoration = enum(u32) { RelaxedPrecision = 0, @@ -6120,18 +4219,26 @@ pub const Decoration = enum(u32) { MaxByteOffsetId = 47, NoSignedWrap = 4469, NoUnsignedWrap = 4470, + WeightTextureQCOM = 4487, + BlockMatchTextureQCOM = 4488, + BlockMatchSamplerQCOM = 4499, ExplicitInterpAMD = 4999, + NodeSharesPayloadLimitsWithAMDX = 5019, + NodeMaxPayloadsAMDX = 5020, + TrackFinishWritingAMDX = 5078, + PayloadNodeNameAMDX = 5091, OverrideCoverageNV = 5248, PassthroughNV = 5250, ViewportRelativeNV = 5252, SecondaryViewportRelativeNV = 5256, - PerPrimitiveNV = 5271, + PerPrimitiveEXT = 5271, PerViewNV = 5272, PerTaskNV = 5273, PerVertexKHR = 5285, NonUniform = 5300, RestrictPointer = 5355, AliasedPointer = 5356, + HitObjectShaderRecordBufferNV = 5386, BindlessSamplerNV = 5398, BindlessImageNV = 5399, BoundSamplerNV = 5400, @@ -6162,19 +4269,47 @@ pub const Decoration = enum(u32) { MergeINTEL = 5834, BankBitsINTEL = 5835, ForcePow2DepthINTEL = 5836, + StridesizeINTEL = 5883, + WordsizeINTEL = 5884, + TrueDualPortINTEL = 5885, BurstCoalesceINTEL = 5899, CacheSizeINTEL = 5900, DontStaticallyCoalesceINTEL = 5901, PrefetchINTEL = 5902, StallEnableINTEL = 5905, FuseLoopsInFunctionINTEL = 5907, + MathOpDSPModeINTEL = 5909, + AliasScopeINTEL = 5914, + NoAliasINTEL = 5915, + InitiationIntervalINTEL = 5917, + MaxConcurrencyINTEL = 5918, + PipelineEnableINTEL = 5919, BufferLocationINTEL = 5921, IOPipeStorageINTEL = 5944, FunctionFloatingPointModeINTEL = 6080, SingleElementVectorINTEL = 6085, VectorComputeCallableFunctionINTEL = 6087, MediaBlockIOINTEL = 6140, + StallFreeINTEL = 6151, + FPMaxErrorDecorationINTEL = 6170, + LatencyControlLabelINTEL = 6172, + LatencyControlConstraintINTEL = 6173, + ConduitKernelArgumentINTEL = 6175, + RegisterMapKernelArgumentINTEL = 6176, + MMHostInterfaceAddressWidthINTEL = 6177, + MMHostInterfaceDataWidthINTEL = 6178, + MMHostInterfaceLatencyINTEL = 6179, + MMHostInterfaceReadWriteModeINTEL = 6180, + MMHostInterfaceMaxBurstINTEL = 6181, + MMHostInterfaceWaitRequestINTEL = 6182, + StableKernelArgumentINTEL = 6183, + HostAccessINTEL = 6188, + InitModeINTEL = 6190, + ImplementInRegisterMapINTEL = 6191, + CacheControlLoadINTEL = 6442, + CacheControlStoreINTEL = 6443, + pub const PerPrimitiveNV = Decoration.PerPrimitiveEXT; pub const PerVertexNV = Decoration.PerVertexKHR; pub const NonUniformEXT = Decoration.NonUniform; pub const RestrictPointerEXT = Decoration.RestrictPointer; @@ -6232,18 +4367,26 @@ pub const Decoration = enum(u32) { MaxByteOffsetId: struct { max_byte_offset: IdRef }, NoSignedWrap, NoUnsignedWrap, + WeightTextureQCOM, + BlockMatchTextureQCOM, + BlockMatchSamplerQCOM, ExplicitInterpAMD, + NodeSharesPayloadLimitsWithAMDX: struct { payload_array: IdRef }, + NodeMaxPayloadsAMDX: struct { max_number_of_payloads: IdRef }, + TrackFinishWritingAMDX, + PayloadNodeNameAMDX: struct { node_name: LiteralString }, OverrideCoverageNV, PassthroughNV, ViewportRelativeNV, SecondaryViewportRelativeNV: struct { offset: LiteralInteger }, - PerPrimitiveNV, + PerPrimitiveEXT, PerViewNV, PerTaskNV, PerVertexKHR, NonUniform, RestrictPointer, AliasedPointer, + HitObjectShaderRecordBufferNV, BindlessSamplerNV, BindlessImageNV, BoundSamplerNV, @@ -6274,18 +4417,45 @@ pub const Decoration = enum(u32) { MergeINTEL: struct { merge_key: LiteralString, merge_type: LiteralString }, BankBitsINTEL: struct { bank_bits: []const LiteralInteger = &.{} }, ForcePow2DepthINTEL: struct { force_key: LiteralInteger }, + StridesizeINTEL: struct { stride_size: LiteralInteger }, + WordsizeINTEL: struct { word_size: LiteralInteger }, + TrueDualPortINTEL, BurstCoalesceINTEL, CacheSizeINTEL: struct { cache_size_in_bytes: LiteralInteger }, DontStaticallyCoalesceINTEL, PrefetchINTEL: struct { prefetcher_size_in_bytes: LiteralInteger }, StallEnableINTEL, FuseLoopsInFunctionINTEL, + MathOpDSPModeINTEL: struct { mode: LiteralInteger, propagate: LiteralInteger }, + AliasScopeINTEL: struct { aliasing_scopes_list: IdRef }, + NoAliasINTEL: struct { aliasing_scopes_list: IdRef }, + InitiationIntervalINTEL: struct { cycles: LiteralInteger }, + MaxConcurrencyINTEL: struct { invocations: LiteralInteger }, + PipelineEnableINTEL: struct { enable: LiteralInteger }, BufferLocationINTEL: struct { buffer_location_id: LiteralInteger }, IOPipeStorageINTEL: struct { io_pipe_id: LiteralInteger }, FunctionFloatingPointModeINTEL: struct { target_width: LiteralInteger, fp_operation_mode: FPOperationMode }, SingleElementVectorINTEL, VectorComputeCallableFunctionINTEL, MediaBlockIOINTEL, + StallFreeINTEL, + FPMaxErrorDecorationINTEL: struct { max_error: LiteralFloat }, + LatencyControlLabelINTEL: struct { latency_label: LiteralInteger }, + LatencyControlConstraintINTEL: struct { relative_to: LiteralInteger, control_type: LiteralInteger, relative_cycle: LiteralInteger }, + ConduitKernelArgumentINTEL, + RegisterMapKernelArgumentINTEL, + MMHostInterfaceAddressWidthINTEL: struct { addresswidth: LiteralInteger }, + MMHostInterfaceDataWidthINTEL: struct { datawidth: LiteralInteger }, + MMHostInterfaceLatencyINTEL: struct { latency: LiteralInteger }, + MMHostInterfaceReadWriteModeINTEL: struct { readwritemode: AccessQualifier }, + MMHostInterfaceMaxBurstINTEL: struct { maxburstcount: LiteralInteger }, + MMHostInterfaceWaitRequestINTEL: struct { waitrequest: LiteralInteger }, + StableKernelArgumentINTEL, + HostAccessINTEL: struct { access: HostAccessQualifier, name: LiteralString }, + InitModeINTEL: struct { trigger: InitializationModeQualifier }, + ImplementInRegisterMapINTEL: struct { value: LiteralInteger }, + CacheControlLoadINTEL: struct { cache_level: LiteralInteger, cache_control: LoadCacheControl }, + CacheControlStoreINTEL: struct { cache_level: LiteralInteger, cache_control: StoreCacheControl }, }; }; pub const BuiltIn = enum(u32) { @@ -6330,6 +4500,11 @@ pub const BuiltIn = enum(u32) { SubgroupLocalInvocationId = 41, VertexIndex = 42, InstanceIndex = 43, + CoreIDARM = 4160, + CoreCountARM = 4161, + CoreMaxIDARM = 4162, + WarpIDARM = 4163, + WarpMaxIDARM = 4164, SubgroupEqMask = 4416, SubgroupGeMask = 4417, SubgroupGtMask = 4418, @@ -6350,6 +4525,8 @@ pub const BuiltIn = enum(u32) { BaryCoordSmoothSampleAMD = 4997, BaryCoordPullModelAMD = 4998, FragStencilRefEXT = 5014, + CoalescedInputCountAMDX = 5021, + ShaderIndexAMDX = 5073, ViewportMaskNV = 5253, SecondaryPositionNV = 5257, SecondaryViewportMaskNV = 5258, @@ -6368,6 +4545,10 @@ pub const BuiltIn = enum(u32) { BaryCoordNoPerspKHR = 5287, FragSizeEXT = 5292, FragInvocationCountEXT = 5293, + PrimitivePointIndicesEXT = 5294, + PrimitiveLineIndicesEXT = 5295, + PrimitiveTriangleIndicesEXT = 5296, + CullPrimitiveEXT = 5299, LaunchIdKHR = 5319, LaunchSizeKHR = 5320, WorldRayOriginKHR = 5321, @@ -6382,12 +4563,18 @@ pub const BuiltIn = enum(u32) { HitTNV = 5332, HitKindKHR = 5333, CurrentRayTimeNV = 5334, + HitTriangleVertexPositionsKHR = 5335, + HitMicroTriangleVertexPositionsNV = 5337, + HitMicroTriangleVertexBarycentricsNV = 5344, IncomingRayFlagsKHR = 5351, RayGeometryIndexKHR = 5352, WarpsPerSMNV = 5374, SMCountNV = 5375, WarpIDNV = 5376, SMIDNV = 5377, + HitKindFrontFacingMicroTriangleNV = 5405, + HitKindBackFacingMicroTriangleNV = 5406, + CullMaskKHR = 6021, pub const SubgroupEqMaskKHR = BuiltIn.SubgroupEqMask; pub const SubgroupGeMaskKHR = BuiltIn.SubgroupGeMask; @@ -6508,6 +4695,10 @@ pub const Capability = enum(u32) { ShaderLayer = 69, ShaderViewportIndex = 70, UniformDecoration = 71, + CoreBuiltinsARM = 4165, + TileImageColorReadAccessEXT = 4166, + TileImageDepthReadAccessEXT = 4167, + TileImageStencilReadAccessEXT = 4168, FragmentShadingRateKHR = 4422, SubgroupBallotKHR = 4423, DrawParameters = 4427, @@ -6537,6 +4728,10 @@ pub const Capability = enum(u32) { RayQueryKHR = 4472, RayTraversalPrimitiveCullingKHR = 4478, RayTracingKHR = 4479, + TextureSampleWeightedQCOM = 4484, + TextureBoxFilterQCOM = 4485, + TextureBlockMatchQCOM = 4486, + TextureBlockMatch2QCOM = 4498, Float16ImageAMD = 5008, ImageGatherBiasLodAMD = 5009, FragmentMaskAMD = 5010, @@ -6544,6 +4739,8 @@ pub const Capability = enum(u32) { ImageReadWriteLodAMD = 5015, Int64ImageEXT = 5016, ShaderClockKHR = 5055, + ShaderEnqueueAMDX = 5067, + QuadControlKHR = 5087, SampleMaskOverrideCoverageNV = 5249, GeometryShaderPassthroughNV = 5251, ShaderViewportIndexLayerEXT = 5254, @@ -6553,6 +4750,7 @@ pub const Capability = enum(u32) { FragmentFullyCoveredEXT = 5265, MeshShadingNV = 5266, ImageFootprintNV = 5282, + MeshShadingEXT = 5283, FragmentBarycentricKHR = 5284, ComputeDerivativeGroupQuadsNV = 5288, FragmentDensityEXT = 5291, @@ -6569,6 +4767,7 @@ pub const Capability = enum(u32) { InputAttachmentArrayNonUniformIndexing = 5310, UniformTexelBufferArrayNonUniformIndexing = 5311, StorageTexelBufferArrayNonUniformIndexing = 5312, + RayTracingPositionFetchKHR = 5336, RayTracingNV = 5340, RayTracingMotionBlurNV = 5341, VulkanMemoryModel = 5345, @@ -6582,7 +4781,14 @@ pub const Capability = enum(u32) { ShaderSMBuiltinsNV = 5373, FragmentShaderPixelInterlockEXT = 5378, DemoteToHelperInvocation = 5379, + DisplacementMicromapNV = 5380, + RayTracingOpacityMicromapEXT = 5381, + ShaderInvocationReorderNV = 5383, BindlessTextureNV = 5390, + RayQueryPositionFetchKHR = 5391, + AtomicFloat16VectorNV = 5404, + RayTracingDisplacementMicromapNV = 5409, + RawAccessChainsNV = 5414, SubgroupShuffleINTEL = 5568, SubgroupBufferBlockIOINTEL = 5569, SubgroupImageBlockIOINTEL = 5570, @@ -6615,9 +4821,13 @@ pub const Capability = enum(u32) { FPGAMemoryAccessesINTEL = 5898, FPGAClusterAttributesINTEL = 5904, LoopFuseINTEL = 5906, + FPGADSPControlINTEL = 5908, + MemoryAccessAliasingINTEL = 5910, + FPGAInvocationPipeliningAttributesINTEL = 5916, FPGABufferLocationINTEL = 5920, ArbitraryPrecisionFixedPointINTEL = 5922, USMStorageClassesINTEL = 5935, + RuntimeAlignedAttributeINTEL = 5939, IOPipesINTEL = 5943, BlockingPipesINTEL = 5945, FPGARegINTEL = 5948, @@ -6625,13 +4835,30 @@ pub const Capability = enum(u32) { DotProductInput4x8Bit = 6017, DotProductInput4x8BitPacked = 6018, DotProduct = 6019, + RayCullMaskKHR = 6020, + CooperativeMatrixKHR = 6022, BitInstructions = 6025, + GroupNonUniformRotateKHR = 6026, + FloatControls2 = 6029, AtomicFloat32AddEXT = 6033, AtomicFloat64AddEXT = 6034, - LongConstantCompositeINTEL = 6089, + LongCompositesINTEL = 6089, OptNoneINTEL = 6094, AtomicFloat16AddEXT = 6095, DebugInfoModuleINTEL = 6114, + BFloat16ConversionINTEL = 6115, + SplitBarrierINTEL = 6141, + FPGAClusterAttributesV2INTEL = 6150, + FPGAKernelAttributesv2INTEL = 6161, + FPMaxErrorINTEL = 6169, + FPGALatencyControlINTEL = 6171, + FPGAArgumentInterfacesINTEL = 6174, + GlobalVariableHostAccessINTEL = 6187, + GlobalVariableFPGADecorationsINTEL = 6189, + GroupUniformArithmeticKHR = 6400, + MaskedGatherScatterINTEL = 6427, + CacheControlsINTEL = 6441, + RegisterLimitsINTEL = 6460, pub const StorageUniformBufferBlock16 = Capability.StorageBuffer16BitAccess; pub const StorageUniform16 = Capability.UniformAndStorageBuffer16BitAccess; @@ -6677,3 +4904,11634 @@ pub const PackedVectorFormat = enum(u32) { pub const PackedVectorFormat4x8BitKHR = PackedVectorFormat.PackedVectorFormat4x8Bit; }; +pub const CooperativeMatrixOperands = packed struct { + MatrixASignedComponentsKHR: bool = false, + MatrixBSignedComponentsKHR: bool = false, + MatrixCSignedComponentsKHR: bool = false, + MatrixResultSignedComponentsKHR: bool = false, + SaturatingAccumulationKHR: bool = false, + _reserved_bit_5: bool = false, + _reserved_bit_6: bool = false, + _reserved_bit_7: bool = false, + _reserved_bit_8: bool = false, + _reserved_bit_9: bool = false, + _reserved_bit_10: bool = false, + _reserved_bit_11: bool = false, + _reserved_bit_12: bool = false, + _reserved_bit_13: bool = false, + _reserved_bit_14: bool = false, + _reserved_bit_15: bool = false, + _reserved_bit_16: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const CooperativeMatrixLayout = enum(u32) { + RowMajorKHR = 0, + ColumnMajorKHR = 1, +}; +pub const CooperativeMatrixUse = enum(u32) { + MatrixAKHR = 0, + MatrixBKHR = 1, + MatrixAccumulatorKHR = 2, +}; +pub const InitializationModeQualifier = enum(u32) { + InitOnDeviceReprogramINTEL = 0, + InitOnDeviceResetINTEL = 1, +}; +pub const LoadCacheControl = enum(u32) { + UncachedINTEL = 0, + CachedINTEL = 1, + StreamingINTEL = 2, + InvalidateAfterReadINTEL = 3, + ConstCachedINTEL = 4, +}; +pub const StoreCacheControl = enum(u32) { + UncachedINTEL = 0, + WriteThroughINTEL = 1, + WriteBackINTEL = 2, + StreamingINTEL = 3, +}; +pub const NamedMaximumNumberOfRegisters = enum(u32) { + AutoINTEL = 0, +}; +pub const @"OpenCL.DebugInfo.100.DebugInfoFlags" = packed struct { + FlagIsProtected: bool = false, + FlagIsPrivate: bool = false, + FlagIsLocal: bool = false, + FlagIsDefinition: bool = false, + FlagFwdDecl: bool = false, + FlagArtificial: bool = false, + FlagExplicit: bool = false, + FlagPrototyped: bool = false, + FlagObjectPointer: bool = false, + FlagStaticMember: bool = false, + FlagIndirectVariable: bool = false, + FlagLValueReference: bool = false, + FlagRValueReference: bool = false, + FlagIsOptimized: bool = false, + FlagIsEnumClass: bool = false, + FlagTypePassByValue: bool = false, + FlagTypePassByReference: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const @"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) { + Unspecified = 0, + Address = 1, + Boolean = 2, + Float = 3, + Signed = 4, + SignedChar = 5, + Unsigned = 6, + UnsignedChar = 7, +}; +pub const @"OpenCL.DebugInfo.100.DebugCompositeType" = enum(u32) { + Class = 0, + Structure = 1, + Union = 2, +}; +pub const @"OpenCL.DebugInfo.100.DebugTypeQualifier" = enum(u32) { + ConstType = 0, + VolatileType = 1, + RestrictType = 2, + AtomicType = 3, +}; +pub const @"OpenCL.DebugInfo.100.DebugOperation" = enum(u32) { + Deref = 0, + Plus = 1, + Minus = 2, + PlusUconst = 3, + BitPiece = 4, + Swap = 5, + Xderef = 6, + StackValue = 7, + Constu = 8, + Fragment = 9, + + pub const Extended = union(@"OpenCL.DebugInfo.100.DebugOperation") { + Deref, + Plus, + Minus, + PlusUconst: struct { literal_integer: LiteralInteger }, + BitPiece: struct { literal_integer_0: LiteralInteger, literal_integer_1: LiteralInteger }, + Swap, + Xderef, + StackValue, + Constu: struct { literal_integer: LiteralInteger }, + Fragment: struct { literal_integer_0: LiteralInteger, literal_integer_1: LiteralInteger }, + }; +}; +pub const @"OpenCL.DebugInfo.100.DebugImportedEntity" = enum(u32) { + ImportedModule = 0, + ImportedDeclaration = 1, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" = packed struct { + FlagIsProtected: bool = false, + FlagIsPrivate: bool = false, + FlagIsLocal: bool = false, + FlagIsDefinition: bool = false, + FlagFwdDecl: bool = false, + FlagArtificial: bool = false, + FlagExplicit: bool = false, + FlagPrototyped: bool = false, + FlagObjectPointer: bool = false, + FlagStaticMember: bool = false, + FlagIndirectVariable: bool = false, + FlagLValueReference: bool = false, + FlagRValueReference: bool = false, + FlagIsOptimized: bool = false, + FlagIsEnumClass: bool = false, + FlagTypePassByValue: bool = false, + FlagTypePassByReference: bool = false, + FlagUnknownPhysicalLayout: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" = packed struct { + IdentifierPossibleDuplicates: bool = false, + _reserved_bit_1: bool = false, + _reserved_bit_2: bool = false, + _reserved_bit_3: bool = false, + _reserved_bit_4: bool = false, + _reserved_bit_5: bool = false, + _reserved_bit_6: bool = false, + _reserved_bit_7: bool = false, + _reserved_bit_8: bool = false, + _reserved_bit_9: bool = false, + _reserved_bit_10: bool = false, + _reserved_bit_11: bool = false, + _reserved_bit_12: bool = false, + _reserved_bit_13: bool = false, + _reserved_bit_14: bool = false, + _reserved_bit_15: bool = false, + _reserved_bit_16: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) { + Unspecified = 0, + Address = 1, + Boolean = 2, + Float = 3, + Signed = 4, + SignedChar = 5, + Unsigned = 6, + UnsignedChar = 7, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" = enum(u32) { + Class = 0, + Structure = 1, + Union = 2, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" = enum(u32) { + ConstType = 0, + VolatileType = 1, + RestrictType = 2, + AtomicType = 3, +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugOperation" = enum(u32) { + Deref = 0, + Plus = 1, + Minus = 2, + PlusUconst = 3, + BitPiece = 4, + Swap = 5, + Xderef = 6, + StackValue = 7, + Constu = 8, + Fragment = 9, + + pub const Extended = union(@"NonSemantic.Shader.DebugInfo.100.DebugOperation") { + Deref, + Plus, + Minus, + PlusUconst: struct { id_ref: IdRef }, + BitPiece: struct { id_ref_0: IdRef, id_ref_1: IdRef }, + Swap, + Xderef, + StackValue, + Constu: struct { id_ref: IdRef }, + Fragment: struct { id_ref_0: IdRef, id_ref_1: IdRef }, + }; +}; +pub const @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" = enum(u32) { + ImportedModule = 0, + ImportedDeclaration = 1, +}; +pub const @"NonSemantic.ClspvReflection.6.KernelPropertyFlags" = packed struct { + MayUsePrintf: bool = false, + _reserved_bit_1: bool = false, + _reserved_bit_2: bool = false, + _reserved_bit_3: bool = false, + _reserved_bit_4: bool = false, + _reserved_bit_5: bool = false, + _reserved_bit_6: bool = false, + _reserved_bit_7: bool = false, + _reserved_bit_8: bool = false, + _reserved_bit_9: bool = false, + _reserved_bit_10: bool = false, + _reserved_bit_11: bool = false, + _reserved_bit_12: bool = false, + _reserved_bit_13: bool = false, + _reserved_bit_14: bool = false, + _reserved_bit_15: bool = false, + _reserved_bit_16: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const @"DebugInfo.DebugInfoFlags" = packed struct { + FlagIsProtected: bool = false, + FlagIsPrivate: bool = false, + FlagIsLocal: bool = false, + FlagIsDefinition: bool = false, + FlagFwdDecl: bool = false, + FlagArtificial: bool = false, + FlagExplicit: bool = false, + FlagPrototyped: bool = false, + FlagObjectPointer: bool = false, + FlagStaticMember: bool = false, + FlagIndirectVariable: bool = false, + FlagLValueReference: bool = false, + FlagRValueReference: bool = false, + FlagIsOptimized: bool = false, + _reserved_bit_14: bool = false, + _reserved_bit_15: bool = false, + _reserved_bit_16: bool = false, + _reserved_bit_17: bool = false, + _reserved_bit_18: bool = false, + _reserved_bit_19: bool = false, + _reserved_bit_20: bool = false, + _reserved_bit_21: bool = false, + _reserved_bit_22: bool = false, + _reserved_bit_23: bool = false, + _reserved_bit_24: bool = false, + _reserved_bit_25: bool = false, + _reserved_bit_26: bool = false, + _reserved_bit_27: bool = false, + _reserved_bit_28: bool = false, + _reserved_bit_29: bool = false, + _reserved_bit_30: bool = false, + _reserved_bit_31: bool = false, +}; +pub const @"DebugInfo.DebugBaseTypeAttributeEncoding" = enum(u32) { + Unspecified = 0, + Address = 1, + Boolean = 2, + Float = 4, + Signed = 5, + SignedChar = 6, + Unsigned = 7, + UnsignedChar = 8, +}; +pub const @"DebugInfo.DebugCompositeType" = enum(u32) { + Class = 0, + Structure = 1, + Union = 2, +}; +pub const @"DebugInfo.DebugTypeQualifier" = enum(u32) { + ConstType = 0, + VolatileType = 1, + RestrictType = 2, +}; +pub const @"DebugInfo.DebugOperation" = enum(u32) { + Deref = 0, + Plus = 1, + Minus = 2, + PlusUconst = 3, + BitPiece = 4, + Swap = 5, + Xderef = 6, + StackValue = 7, + Constu = 8, + + pub const Extended = union(@"DebugInfo.DebugOperation") { + Deref, + Plus, + Minus, + PlusUconst: struct { literal_integer: LiteralInteger }, + BitPiece: struct { literal_integer_0: LiteralInteger, literal_integer_1: LiteralInteger }, + Swap, + Xderef, + StackValue, + Constu: struct { literal_integer: LiteralInteger }, + }; +}; +pub const InstructionSet = enum { + core, + @"OpenCL.std", + @"GLSL.std.450", + @"OpenCL.DebugInfo.100", + SPV_AMD_shader_ballot, + @"NonSemantic.Shader.DebugInfo.100", + @"NonSemantic.VkspReflection", + @"NonSemantic.ClspvReflection.6", + SPV_AMD_gcn_shader, + SPV_AMD_shader_trinary_minmax, + DebugInfo, + @"NonSemantic.DebugPrintf", + SPV_AMD_shader_explicit_vertex_parameter, + @"NonSemantic.DebugBreak", + zig, + + pub fn instructions(self: InstructionSet) []const Instruction { + return switch (self) { + .core => &[_]Instruction{ + .{ + .name = "OpNop", + .opcode = 0, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpUndef", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSourceContinued", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpSource", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .SourceLanguage, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .LiteralString, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSourceExtension", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpName", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemberName", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpString", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpLine", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpExtension", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpExtInstImport", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpExtInst", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralExtInstInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpMemoryModel", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .AddressingModel, .quantifier = .required }, + .{ .kind = .MemoryModel, .quantifier = .required }, + }, + }, + .{ + .name = "OpEntryPoint", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .ExecutionModel, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpExecutionMode", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ExecutionMode, .quantifier = .required }, + }, + }, + .{ + .name = "OpCapability", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .Capability, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeVoid", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeBool", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeInt", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeFloat", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeVector", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeMatrix", + .opcode = 24, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeImage", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .Dim, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .ImageFormat, .quantifier = .required }, + .{ .kind = .AccessQualifier, .quantifier = .optional }, + }, + }, + .{ + .name = "OpTypeSampler", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeSampledImage", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeArray", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeRuntimeArray", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeStruct", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpTypeOpaque", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypePointer", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeFunction", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpTypeEvent", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeDeviceEvent", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeReserveId", + .opcode = 36, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeQueue", + .opcode = 37, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypePipe", + .opcode = 38, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .AccessQualifier, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeForwardPointer", + .opcode = 39, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantTrue", + .opcode = 41, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantFalse", + .opcode = 42, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstant", + .opcode = 43, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralContextDependentNumber, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantComposite", + .opcode = 44, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpConstantSampler", + .opcode = 45, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .SamplerAddressingMode, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .SamplerFilterMode, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantNull", + .opcode = 46, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstantTrue", + .opcode = 48, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstantFalse", + .opcode = 49, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstant", + .opcode = 50, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralContextDependentNumber, .quantifier = .required }, + }, + }, + .{ + .name = "OpSpecConstantComposite", + .opcode = 51, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpSpecConstantOp", + .opcode = 52, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralSpecConstantOpInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFunction", + .opcode = 54, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .FunctionControl, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFunctionParameter", + .opcode = 55, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpFunctionEnd", + .opcode = 56, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpFunctionCall", + .opcode = 57, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpVariable", + .opcode = 59, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageTexelPointer", + .opcode = 60, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLoad", + .opcode = 61, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpStore", + .opcode = 62, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCopyMemory", + .opcode = 63, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCopyMemorySized", + .opcode = 64, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpAccessChain", + .opcode = 65, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpInBoundsAccessChain", + .opcode = 66, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpPtrAccessChain", + .opcode = 67, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpArrayLength", + .opcode = 68, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpGenericPtrMemSemantics", + .opcode = 69, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpInBoundsPtrAccessChain", + .opcode = 70, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpDecorate", + .opcode = 71, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemberDecorate", + .opcode = 72, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpDecorationGroup", + .opcode = 73, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupDecorate", + .opcode = 74, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpGroupMemberDecorate", + .opcode = 75, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PairIdRefLiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpVectorExtractDynamic", + .opcode = 77, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpVectorInsertDynamic", + .opcode = 78, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpVectorShuffle", + .opcode = 79, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpCompositeConstruct", + .opcode = 80, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpCompositeExtract", + .opcode = 81, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpCompositeInsert", + .opcode = 82, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpCopyObject", + .opcode = 83, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTranspose", + .opcode = 84, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSampledImage", + .opcode = 86, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleImplicitLod", + .opcode = 87, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSampleExplicitLod", + .opcode = 88, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleDrefImplicitLod", + .opcode = 89, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSampleDrefExplicitLod", + .opcode = 90, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleProjImplicitLod", + .opcode = 91, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSampleProjExplicitLod", + .opcode = 92, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleProjDrefImplicitLod", + .opcode = 93, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSampleProjDrefExplicitLod", + .opcode = 94, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageFetch", + .opcode = 95, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageGather", + .opcode = 96, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageDrefGather", + .opcode = 97, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageRead", + .opcode = 98, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageWrite", + .opcode = 99, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImage", + .opcode = 100, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQueryFormat", + .opcode = 101, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQueryOrder", + .opcode = 102, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQuerySizeLod", + .opcode = 103, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQuerySize", + .opcode = 104, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQueryLod", + .opcode = 105, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQueryLevels", + .opcode = 106, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageQuerySamples", + .opcode = 107, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertFToU", + .opcode = 109, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertFToS", + .opcode = 110, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertSToF", + .opcode = 111, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToF", + .opcode = 112, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUConvert", + .opcode = 113, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSConvert", + .opcode = 114, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFConvert", + .opcode = 115, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpQuantizeToF16", + .opcode = 116, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertPtrToU", + .opcode = 117, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSatConvertSToU", + .opcode = 118, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSatConvertUToS", + .opcode = 119, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToPtr", + .opcode = 120, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpPtrCastToGeneric", + .opcode = 121, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGenericCastToPtr", + .opcode = 122, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGenericCastToPtrExplicit", + .opcode = 123, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitcast", + .opcode = 124, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSNegate", + .opcode = 126, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFNegate", + .opcode = 127, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIAdd", + .opcode = 128, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFAdd", + .opcode = 129, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpISub", + .opcode = 130, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFSub", + .opcode = 131, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIMul", + .opcode = 132, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFMul", + .opcode = 133, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUDiv", + .opcode = 134, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSDiv", + .opcode = 135, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFDiv", + .opcode = 136, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUMod", + .opcode = 137, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSRem", + .opcode = 138, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSMod", + .opcode = 139, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFRem", + .opcode = 140, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFMod", + .opcode = 141, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpVectorTimesScalar", + .opcode = 142, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMatrixTimesScalar", + .opcode = 143, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpVectorTimesMatrix", + .opcode = 144, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMatrixTimesVector", + .opcode = 145, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMatrixTimesMatrix", + .opcode = 146, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpOuterProduct", + .opcode = 147, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDot", + .opcode = 148, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIAddCarry", + .opcode = 149, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpISubBorrow", + .opcode = 150, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUMulExtended", + .opcode = 151, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSMulExtended", + .opcode = 152, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAny", + .opcode = 154, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAll", + .opcode = 155, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsNan", + .opcode = 156, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsInf", + .opcode = 157, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsFinite", + .opcode = 158, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsNormal", + .opcode = 159, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSignBitSet", + .opcode = 160, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLessOrGreater", + .opcode = 161, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpOrdered", + .opcode = 162, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUnordered", + .opcode = 163, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLogicalEqual", + .opcode = 164, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLogicalNotEqual", + .opcode = 165, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLogicalOr", + .opcode = 166, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLogicalAnd", + .opcode = 167, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpLogicalNot", + .opcode = 168, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSelect", + .opcode = 169, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIEqual", + .opcode = 170, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpINotEqual", + .opcode = 171, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUGreaterThan", + .opcode = 172, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSGreaterThan", + .opcode = 173, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUGreaterThanEqual", + .opcode = 174, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSGreaterThanEqual", + .opcode = 175, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpULessThan", + .opcode = 176, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSLessThan", + .opcode = 177, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpULessThanEqual", + .opcode = 178, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSLessThanEqual", + .opcode = 179, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdEqual", + .opcode = 180, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordEqual", + .opcode = 181, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdNotEqual", + .opcode = 182, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordNotEqual", + .opcode = 183, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdLessThan", + .opcode = 184, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordLessThan", + .opcode = 185, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdGreaterThan", + .opcode = 186, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordGreaterThan", + .opcode = 187, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdLessThanEqual", + .opcode = 188, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordLessThanEqual", + .opcode = 189, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFOrdGreaterThanEqual", + .opcode = 190, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFUnordGreaterThanEqual", + .opcode = 191, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpShiftRightLogical", + .opcode = 194, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpShiftRightArithmetic", + .opcode = 195, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpShiftLeftLogical", + .opcode = 196, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitwiseOr", + .opcode = 197, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitwiseXor", + .opcode = 198, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitwiseAnd", + .opcode = 199, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpNot", + .opcode = 200, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitFieldInsert", + .opcode = 201, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitFieldSExtract", + .opcode = 202, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitFieldUExtract", + .opcode = 203, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitReverse", + .opcode = 204, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBitCount", + .opcode = 205, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdx", + .opcode = 207, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdy", + .opcode = 208, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFwidth", + .opcode = 209, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdxFine", + .opcode = 210, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdyFine", + .opcode = 211, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFwidthFine", + .opcode = 212, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdxCoarse", + .opcode = 213, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDPdyCoarse", + .opcode = 214, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFwidthCoarse", + .opcode = 215, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpEmitVertex", + .opcode = 218, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpEndPrimitive", + .opcode = 219, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpEmitStreamVertex", + .opcode = 220, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpEndStreamPrimitive", + .opcode = 221, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpControlBarrier", + .opcode = 224, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemoryBarrier", + .opcode = 225, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicLoad", + .opcode = 227, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicStore", + .opcode = 228, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicExchange", + .opcode = 229, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicCompareExchange", + .opcode = 230, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicCompareExchangeWeak", + .opcode = 231, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicIIncrement", + .opcode = 232, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicIDecrement", + .opcode = 233, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicIAdd", + .opcode = 234, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicISub", + .opcode = 235, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicSMin", + .opcode = 236, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicUMin", + .opcode = 237, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicSMax", + .opcode = 238, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicUMax", + .opcode = 239, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicAnd", + .opcode = 240, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicOr", + .opcode = 241, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicXor", + .opcode = 242, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpPhi", + .opcode = 245, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpLoopMerge", + .opcode = 246, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LoopControl, .quantifier = .required }, + }, + }, + .{ + .name = "OpSelectionMerge", + .opcode = 247, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .SelectionControl, .quantifier = .required }, + }, + }, + .{ + .name = "OpLabel", + .opcode = 248, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpBranch", + .opcode = 249, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBranchConditional", + .opcode = 250, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpSwitch", + .opcode = 251, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PairLiteralIntegerIdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpKill", + .opcode = 252, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpReturn", + .opcode = 253, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpReturnValue", + .opcode = 254, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUnreachable", + .opcode = 255, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpLifetimeStart", + .opcode = 256, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpLifetimeStop", + .opcode = 257, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupAsyncCopy", + .opcode = 259, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupWaitEvents", + .opcode = 260, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupAll", + .opcode = 261, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupAny", + .opcode = 262, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupBroadcast", + .opcode = 263, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupIAdd", + .opcode = 264, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFAdd", + .opcode = 265, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFMin", + .opcode = 266, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupUMin", + .opcode = 267, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupSMin", + .opcode = 268, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFMax", + .opcode = 269, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupUMax", + .opcode = 270, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupSMax", + .opcode = 271, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReadPipe", + .opcode = 274, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpWritePipe", + .opcode = 275, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReservedReadPipe", + .opcode = 276, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReservedWritePipe", + .opcode = 277, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReserveReadPipePackets", + .opcode = 278, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReserveWritePipePackets", + .opcode = 279, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCommitReadPipe", + .opcode = 280, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCommitWritePipe", + .opcode = 281, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsValidReserveId", + .opcode = 282, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetNumPipePackets", + .opcode = 283, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetMaxPipePackets", + .opcode = 284, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupReserveReadPipePackets", + .opcode = 285, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupReserveWritePipePackets", + .opcode = 286, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupCommitReadPipe", + .opcode = 287, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupCommitWritePipe", + .opcode = 288, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpEnqueueMarker", + .opcode = 291, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpEnqueueKernel", + .opcode = 292, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpGetKernelNDrangeSubGroupCount", + .opcode = 293, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetKernelNDrangeMaxSubGroupSize", + .opcode = 294, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetKernelWorkGroupSize", + .opcode = 295, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetKernelPreferredWorkGroupSizeMultiple", + .opcode = 296, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRetainEvent", + .opcode = 297, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReleaseEvent", + .opcode = 298, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCreateUserEvent", + .opcode = 299, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpIsValidEvent", + .opcode = 300, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSetUserEventStatus", + .opcode = 301, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCaptureEventProfilingInfo", + .opcode = 302, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetDefaultQueue", + .opcode = 303, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpBuildNDRange", + .opcode = 304, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseSampleImplicitLod", + .opcode = 305, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseSampleExplicitLod", + .opcode = 306, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseSampleDrefImplicitLod", + .opcode = 307, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseSampleDrefExplicitLod", + .opcode = 308, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseSampleProjImplicitLod", + .opcode = 309, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseSampleProjExplicitLod", + .opcode = 310, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseSampleProjDrefImplicitLod", + .opcode = 311, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseSampleProjDrefExplicitLod", + .opcode = 312, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseFetch", + .opcode = 313, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseGather", + .opcode = 314, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseDrefGather", + .opcode = 315, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpImageSparseTexelsResident", + .opcode = 316, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpNoLine", + .opcode = 317, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpAtomicFlagTestAndSet", + .opcode = 318, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicFlagClear", + .opcode = 319, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSparseRead", + .opcode = 320, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSizeOf", + .opcode = 321, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypePipeStorage", + .opcode = 322, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantPipeStorage", + .opcode = 323, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpCreatePipeFromPipeStorage", + .opcode = 324, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetKernelLocalSizeForSubgroupCount", + .opcode = 325, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGetKernelMaxNumSubgroups", + .opcode = 326, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeNamedBarrier", + .opcode = 327, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpNamedBarrierInitialize", + .opcode = 328, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemoryNamedBarrier", + .opcode = 329, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpModuleProcessed", + .opcode = 330, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpExecutionModeId", + .opcode = 331, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ExecutionMode, .quantifier = .required }, + }, + }, + .{ + .name = "OpDecorateId", + .opcode = 332, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformElect", + .opcode = 333, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformAll", + .opcode = 334, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformAny", + .opcode = 335, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformAllEqual", + .opcode = 336, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBroadcast", + .opcode = 337, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBroadcastFirst", + .opcode = 338, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBallot", + .opcode = 339, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformInverseBallot", + .opcode = 340, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBallotBitExtract", + .opcode = 341, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBallotBitCount", + .opcode = 342, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBallotFindLSB", + .opcode = 343, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformBallotFindMSB", + .opcode = 344, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformShuffle", + .opcode = 345, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformShuffleXor", + .opcode = 346, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformShuffleUp", + .opcode = 347, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformShuffleDown", + .opcode = 348, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformIAdd", + .opcode = 349, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformFAdd", + .opcode = 350, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformIMul", + .opcode = 351, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformFMul", + .opcode = 352, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformSMin", + .opcode = 353, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformUMin", + .opcode = 354, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformFMin", + .opcode = 355, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformSMax", + .opcode = 356, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformUMax", + .opcode = 357, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformFMax", + .opcode = 358, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformBitwiseAnd", + .opcode = 359, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformBitwiseOr", + .opcode = 360, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformBitwiseXor", + .opcode = 361, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformLogicalAnd", + .opcode = 362, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformLogicalOr", + .opcode = 363, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformLogicalXor", + .opcode = 364, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpGroupNonUniformQuadBroadcast", + .opcode = 365, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformQuadSwap", + .opcode = 366, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCopyLogical", + .opcode = 400, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpPtrEqual", + .opcode = 401, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpPtrNotEqual", + .opcode = 402, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpPtrDiff", + .opcode = 403, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpColorAttachmentReadEXT", + .opcode = 4160, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpDepthAttachmentReadEXT", + .opcode = 4161, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpStencilAttachmentReadEXT", + .opcode = 4162, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpTerminateInvocation", + .opcode = 4416, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpSubgroupBallotKHR", + .opcode = 4421, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupFirstInvocationKHR", + .opcode = 4422, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAllKHR", + .opcode = 4428, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAnyKHR", + .opcode = 4429, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAllEqualKHR", + .opcode = 4430, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformRotateKHR", + .opcode = 4431, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSubgroupReadInvocationKHR", + .opcode = 4432, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTraceRayKHR", + .opcode = 4445, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpExecuteCallableKHR", + .opcode = 4446, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToAccelerationStructureKHR", + .opcode = 4447, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIgnoreIntersectionKHR", + .opcode = 4448, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpTerminateRayKHR", + .opcode = 4449, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpSDot", + .opcode = 4450, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSDotKHR", + .opcode = 4450, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpUDot", + .opcode = 4451, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpUDotKHR", + .opcode = 4451, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSUDot", + .opcode = 4452, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSUDotKHR", + .opcode = 4452, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSDotAccSat", + .opcode = 4453, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSDotAccSatKHR", + .opcode = 4453, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpUDotAccSat", + .opcode = 4454, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpUDotAccSatKHR", + .opcode = 4454, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSUDotAccSat", + .opcode = 4455, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSUDotAccSatKHR", + .opcode = 4455, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PackedVectorFormat, .quantifier = .optional }, + }, + }, + .{ + .name = "OpTypeCooperativeMatrixKHR", + .opcode = 4456, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCooperativeMatrixLoadKHR", + .opcode = 4457, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCooperativeMatrixStoreKHR", + .opcode = 4458, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCooperativeMatrixMulAddKHR", + .opcode = 4459, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .CooperativeMatrixOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCooperativeMatrixLengthKHR", + .opcode = 4460, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeRayQueryKHR", + .opcode = 4472, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryInitializeKHR", + .opcode = 4473, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryTerminateKHR", + .opcode = 4474, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGenerateIntersectionKHR", + .opcode = 4475, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryConfirmIntersectionKHR", + .opcode = 4476, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryProceedKHR", + .opcode = 4477, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionTypeKHR", + .opcode = 4479, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleWeightedQCOM", + .opcode = 4480, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBoxFilterQCOM", + .opcode = 4481, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchSSDQCOM", + .opcode = 4482, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchSADQCOM", + .opcode = 4483, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchWindowSSDQCOM", + .opcode = 4500, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchWindowSADQCOM", + .opcode = 4501, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchGatherSSDQCOM", + .opcode = 4502, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageBlockMatchGatherSADQCOM", + .opcode = 4503, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupIAddNonUniformAMD", + .opcode = 5000, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFAddNonUniformAMD", + .opcode = 5001, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFMinNonUniformAMD", + .opcode = 5002, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupUMinNonUniformAMD", + .opcode = 5003, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupSMinNonUniformAMD", + .opcode = 5004, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFMaxNonUniformAMD", + .opcode = 5005, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupUMaxNonUniformAMD", + .opcode = 5006, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupSMaxNonUniformAMD", + .opcode = 5007, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFragmentMaskFetchAMD", + .opcode = 5011, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFragmentFetchAMD", + .opcode = 5012, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReadClockKHR", + .opcode = 5056, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + }, + }, + .{ + .name = "OpFinalizeNodePayloadsAMDX", + .opcode = 5075, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFinishWritingNodePayloadAMDX", + .opcode = 5078, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpInitializeNodePayloadsAMDX", + .opcode = 5090, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformQuadAllKHR", + .opcode = 5110, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformQuadAnyKHR", + .opcode = 5111, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordHitMotionNV", + .opcode = 5249, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordHitWithIndexMotionNV", + .opcode = 5250, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordMissMotionNV", + .opcode = 5251, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetWorldToObjectNV", + .opcode = 5252, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetObjectToWorldNV", + .opcode = 5253, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetObjectRayDirectionNV", + .opcode = 5254, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetObjectRayOriginNV", + .opcode = 5255, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectTraceRayMotionNV", + .opcode = 5256, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetShaderRecordBufferHandleNV", + .opcode = 5257, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetShaderBindingTableRecordIndexNV", + .opcode = 5258, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordEmptyNV", + .opcode = 5259, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectTraceRayNV", + .opcode = 5260, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordHitNV", + .opcode = 5261, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordHitWithIndexNV", + .opcode = 5262, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectRecordMissNV", + .opcode = 5263, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectExecuteShaderNV", + .opcode = 5264, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetCurrentTimeNV", + .opcode = 5265, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetAttributesNV", + .opcode = 5266, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetHitKindNV", + .opcode = 5267, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetPrimitiveIndexNV", + .opcode = 5268, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetGeometryIndexNV", + .opcode = 5269, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetInstanceIdNV", + .opcode = 5270, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetInstanceCustomIndexNV", + .opcode = 5271, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetWorldRayDirectionNV", + .opcode = 5272, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetWorldRayOriginNV", + .opcode = 5273, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetRayTMaxNV", + .opcode = 5274, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectGetRayTMinNV", + .opcode = 5275, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectIsEmptyNV", + .opcode = 5276, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectIsHitNV", + .opcode = 5277, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpHitObjectIsMissNV", + .opcode = 5278, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReorderThreadWithHitObjectNV", + .opcode = 5279, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpReorderThreadWithHintNV", + .opcode = 5280, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeHitObjectNV", + .opcode = 5281, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpImageSampleFootprintNV", + .opcode = 5283, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .ImageOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpEmitMeshTasksEXT", + .opcode = 5294, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSetMeshOutputsEXT", + .opcode = 5295, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupNonUniformPartitionNV", + .opcode = 5296, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpWritePackedPrimitiveIndices4x8NV", + .opcode = 5299, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFetchMicroTriangleVertexPositionNV", + .opcode = 5300, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFetchMicroTriangleVertexBarycentricNV", + .opcode = 5301, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReportIntersectionNV", + .opcode = 5334, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReportIntersectionKHR", + .opcode = 5334, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIgnoreIntersectionNV", + .opcode = 5335, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpTerminateRayNV", + .opcode = 5336, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpTraceNV", + .opcode = 5337, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTraceMotionNV", + .opcode = 5338, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTraceRayMotionNV", + .opcode = 5339, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionTriangleVertexPositionsKHR", + .opcode = 5340, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAccelerationStructureNV", + .opcode = 5341, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAccelerationStructureKHR", + .opcode = 5341, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpExecuteCallableNV", + .opcode = 5344, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeCooperativeMatrixNV", + .opcode = 5358, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCooperativeMatrixLoadNV", + .opcode = 5359, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCooperativeMatrixStoreNV", + .opcode = 5360, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .MemoryAccess, .quantifier = .optional }, + }, + }, + .{ + .name = "OpCooperativeMatrixMulAddNV", + .opcode = 5361, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCooperativeMatrixLengthNV", + .opcode = 5362, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpBeginInvocationInterlockEXT", + .opcode = 5364, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpEndInvocationInterlockEXT", + .opcode = 5365, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpDemoteToHelperInvocation", + .opcode = 5380, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpDemoteToHelperInvocationEXT", + .opcode = 5380, + .operands = &[_]Operand{}, + }, + .{ + .name = "OpIsHelperInvocationEXT", + .opcode = 5381, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToImageNV", + .opcode = 5391, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToSamplerNV", + .opcode = 5392, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertImageToUNV", + .opcode = 5393, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertSamplerToUNV", + .opcode = 5394, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertUToSampledImageNV", + .opcode = 5395, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertSampledImageToUNV", + .opcode = 5396, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSamplerImageAddressingModeNV", + .opcode = 5397, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpRawAccessChainNV", + .opcode = 5398, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .RawAccessChainOperands, .quantifier = .optional }, + }, + }, + .{ + .name = "OpSubgroupShuffleINTEL", + .opcode = 5571, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupShuffleDownINTEL", + .opcode = 5572, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupShuffleUpINTEL", + .opcode = 5573, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupShuffleXorINTEL", + .opcode = 5574, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupBlockReadINTEL", + .opcode = 5575, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupBlockWriteINTEL", + .opcode = 5576, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupImageBlockReadINTEL", + .opcode = 5577, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupImageBlockWriteINTEL", + .opcode = 5578, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupImageMediaBlockReadINTEL", + .opcode = 5580, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupImageMediaBlockWriteINTEL", + .opcode = 5581, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUCountLeadingZerosINTEL", + .opcode = 5585, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUCountTrailingZerosINTEL", + .opcode = 5586, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAbsISubINTEL", + .opcode = 5587, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAbsUSubINTEL", + .opcode = 5588, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIAddSatINTEL", + .opcode = 5589, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUAddSatINTEL", + .opcode = 5590, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIAverageINTEL", + .opcode = 5591, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUAverageINTEL", + .opcode = 5592, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIAverageRoundedINTEL", + .opcode = 5593, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUAverageRoundedINTEL", + .opcode = 5594, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpISubSatINTEL", + .opcode = 5595, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUSubSatINTEL", + .opcode = 5596, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpIMul32x16INTEL", + .opcode = 5597, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpUMul32x16INTEL", + .opcode = 5598, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConstantFunctionPointerINTEL", + .opcode = 5600, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFunctionPointerCallINTEL", + .opcode = 5601, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpAsmTargetINTEL", + .opcode = 5609, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpAsmINTEL", + .opcode = 5610, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "OpAsmCallINTEL", + .opcode = 5611, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpAtomicFMinEXT", + .opcode = 5614, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicFMaxEXT", + .opcode = 5615, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAssumeTrueKHR", + .opcode = 5630, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpExpectKHR", + .opcode = 5631, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpDecorateString", + .opcode = 5632, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpDecorateStringGOOGLE", + .opcode = 5632, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemberDecorateString", + .opcode = 5633, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpMemberDecorateStringGOOGLE", + .opcode = 5633, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .Decoration, .quantifier = .required }, + }, + }, + .{ + .name = "OpVmeImageINTEL", + .opcode = 5699, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeVmeImageINTEL", + .opcode = 5700, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImePayloadINTEL", + .opcode = 5701, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcRefPayloadINTEL", + .opcode = 5702, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcSicPayloadINTEL", + .opcode = 5703, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcMcePayloadINTEL", + .opcode = 5704, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcMceResultINTEL", + .opcode = 5705, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImeResultINTEL", + .opcode = 5706, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImeResultSingleReferenceStreamoutINTEL", + .opcode = 5707, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImeResultDualReferenceStreamoutINTEL", + .opcode = 5708, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImeSingleReferenceStreaminINTEL", + .opcode = 5709, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcImeDualReferenceStreaminINTEL", + .opcode = 5710, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcRefResultINTEL", + .opcode = 5711, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeAvcSicResultINTEL", + .opcode = 5712, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultInterBaseMultiReferencePenaltyINTEL", + .opcode = 5713, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetInterBaseMultiReferencePenaltyINTEL", + .opcode = 5714, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultInterShapePenaltyINTEL", + .opcode = 5715, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetInterShapePenaltyINTEL", + .opcode = 5716, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultInterDirectionPenaltyINTEL", + .opcode = 5717, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetInterDirectionPenaltyINTEL", + .opcode = 5718, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultIntraLumaShapePenaltyINTEL", + .opcode = 5719, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultInterMotionVectorCostTableINTEL", + .opcode = 5720, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultHighPenaltyCostTableINTEL", + .opcode = 5721, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultMediumPenaltyCostTableINTEL", + .opcode = 5722, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultLowPenaltyCostTableINTEL", + .opcode = 5723, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetMotionVectorCostFunctionINTEL", + .opcode = 5724, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultIntraLumaModePenaltyINTEL", + .opcode = 5725, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultNonDcLumaIntraPenaltyINTEL", + .opcode = 5726, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetDefaultIntraChromaModeBasePenaltyINTEL", + .opcode = 5727, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetAcOnlyHaarINTEL", + .opcode = 5728, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetSourceInterlacedFieldPolarityINTEL", + .opcode = 5729, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetSingleReferenceInterlacedFieldPolarityINTEL", + .opcode = 5730, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceSetDualReferenceInterlacedFieldPolaritiesINTEL", + .opcode = 5731, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToImePayloadINTEL", + .opcode = 5732, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToImeResultINTEL", + .opcode = 5733, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToRefPayloadINTEL", + .opcode = 5734, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToRefResultINTEL", + .opcode = 5735, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToSicPayloadINTEL", + .opcode = 5736, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceConvertToSicResultINTEL", + .opcode = 5737, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetMotionVectorsINTEL", + .opcode = 5738, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterDistortionsINTEL", + .opcode = 5739, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetBestInterDistortionsINTEL", + .opcode = 5740, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterMajorShapeINTEL", + .opcode = 5741, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterMinorShapeINTEL", + .opcode = 5742, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterDirectionsINTEL", + .opcode = 5743, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterMotionVectorCountINTEL", + .opcode = 5744, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterReferenceIdsINTEL", + .opcode = 5745, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcMceGetInterReferenceInterlacedFieldPolaritiesINTEL", + .opcode = 5746, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeInitializeINTEL", + .opcode = 5747, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetSingleReferenceINTEL", + .opcode = 5748, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetDualReferenceINTEL", + .opcode = 5749, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeRefWindowSizeINTEL", + .opcode = 5750, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeAdjustRefOffsetINTEL", + .opcode = 5751, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeConvertToMcePayloadINTEL", + .opcode = 5752, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetMaxMotionVectorCountINTEL", + .opcode = 5753, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetUnidirectionalMixDisableINTEL", + .opcode = 5754, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetEarlySearchTerminationThresholdINTEL", + .opcode = 5755, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeSetWeightedSadINTEL", + .opcode = 5756, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithSingleReferenceINTEL", + .opcode = 5757, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithDualReferenceINTEL", + .opcode = 5758, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminINTEL", + .opcode = 5759, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminINTEL", + .opcode = 5760, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithSingleReferenceStreamoutINTEL", + .opcode = 5761, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithDualReferenceStreamoutINTEL", + .opcode = 5762, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithSingleReferenceStreaminoutINTEL", + .opcode = 5763, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeEvaluateWithDualReferenceStreaminoutINTEL", + .opcode = 5764, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeConvertToMceResultINTEL", + .opcode = 5765, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetSingleReferenceStreaminINTEL", + .opcode = 5766, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetDualReferenceStreaminINTEL", + .opcode = 5767, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeStripSingleReferenceStreamoutINTEL", + .opcode = 5768, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeStripDualReferenceStreamoutINTEL", + .opcode = 5769, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeMotionVectorsINTEL", + .opcode = 5770, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeDistortionsINTEL", + .opcode = 5771, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutSingleReferenceMajorShapeReferenceIdsINTEL", + .opcode = 5772, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeMotionVectorsINTEL", + .opcode = 5773, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeDistortionsINTEL", + .opcode = 5774, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetStreamoutDualReferenceMajorShapeReferenceIdsINTEL", + .opcode = 5775, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetBorderReachedINTEL", + .opcode = 5776, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetTruncatedSearchIndicationINTEL", + .opcode = 5777, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetUnidirectionalEarlySearchTerminationINTEL", + .opcode = 5778, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetWeightingPatternMinimumMotionVectorINTEL", + .opcode = 5779, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcImeGetWeightingPatternMinimumDistortionINTEL", + .opcode = 5780, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcFmeInitializeINTEL", + .opcode = 5781, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcBmeInitializeINTEL", + .opcode = 5782, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefConvertToMcePayloadINTEL", + .opcode = 5783, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefSetBidirectionalMixDisableINTEL", + .opcode = 5784, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefSetBilinearFilterEnableINTEL", + .opcode = 5785, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefEvaluateWithSingleReferenceINTEL", + .opcode = 5786, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefEvaluateWithDualReferenceINTEL", + .opcode = 5787, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefEvaluateWithMultiReferenceINTEL", + .opcode = 5788, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefEvaluateWithMultiReferenceInterlacedINTEL", + .opcode = 5789, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcRefConvertToMceResultINTEL", + .opcode = 5790, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicInitializeINTEL", + .opcode = 5791, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicConfigureSkcINTEL", + .opcode = 5792, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicConfigureIpeLumaINTEL", + .opcode = 5793, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicConfigureIpeLumaChromaINTEL", + .opcode = 5794, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetMotionVectorMaskINTEL", + .opcode = 5795, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicConvertToMcePayloadINTEL", + .opcode = 5796, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetIntraLumaShapePenaltyINTEL", + .opcode = 5797, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetIntraLumaModeCostFunctionINTEL", + .opcode = 5798, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetIntraChromaModeCostFunctionINTEL", + .opcode = 5799, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetBilinearFilterEnableINTEL", + .opcode = 5800, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetSkcForwardTransformEnableINTEL", + .opcode = 5801, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicSetBlockBasedRawSkipSadINTEL", + .opcode = 5802, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicEvaluateIpeINTEL", + .opcode = 5803, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicEvaluateWithSingleReferenceINTEL", + .opcode = 5804, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicEvaluateWithDualReferenceINTEL", + .opcode = 5805, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicEvaluateWithMultiReferenceINTEL", + .opcode = 5806, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicEvaluateWithMultiReferenceInterlacedINTEL", + .opcode = 5807, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicConvertToMceResultINTEL", + .opcode = 5808, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetIpeLumaShapeINTEL", + .opcode = 5809, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetBestIpeLumaDistortionINTEL", + .opcode = 5810, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetBestIpeChromaDistortionINTEL", + .opcode = 5811, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetPackedIpeLumaModesINTEL", + .opcode = 5812, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetIpeChromaModeINTEL", + .opcode = 5813, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetPackedSkcLumaCountThresholdINTEL", + .opcode = 5814, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetPackedSkcLumaSumThresholdINTEL", + .opcode = 5815, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSubgroupAvcSicGetInterRawSadsINTEL", + .opcode = 5816, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpVariableLengthArrayINTEL", + .opcode = 5818, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpSaveMemoryINTEL", + .opcode = 5819, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + }, + }, + .{ + .name = "OpRestoreMemoryINTEL", + .opcode = 5820, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSinCosPiINTEL", + .opcode = 5840, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCastINTEL", + .opcode = 5841, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCastFromIntINTEL", + .opcode = 5842, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCastToIntINTEL", + .opcode = 5843, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatAddINTEL", + .opcode = 5846, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSubINTEL", + .opcode = 5847, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatMulINTEL", + .opcode = 5848, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatDivINTEL", + .opcode = 5849, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatGTINTEL", + .opcode = 5850, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatGEINTEL", + .opcode = 5851, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLTINTEL", + .opcode = 5852, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLEINTEL", + .opcode = 5853, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatEQINTEL", + .opcode = 5854, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatRecipINTEL", + .opcode = 5855, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatRSqrtINTEL", + .opcode = 5856, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCbrtINTEL", + .opcode = 5857, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatHypotINTEL", + .opcode = 5858, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSqrtINTEL", + .opcode = 5859, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLogINTEL", + .opcode = 5860, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLog2INTEL", + .opcode = 5861, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLog10INTEL", + .opcode = 5862, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatLog1pINTEL", + .opcode = 5863, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatExpINTEL", + .opcode = 5864, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatExp2INTEL", + .opcode = 5865, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatExp10INTEL", + .opcode = 5866, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatExpm1INTEL", + .opcode = 5867, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSinINTEL", + .opcode = 5868, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCosINTEL", + .opcode = 5869, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSinCosINTEL", + .opcode = 5870, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatSinPiINTEL", + .opcode = 5871, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatCosPiINTEL", + .opcode = 5872, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatASinINTEL", + .opcode = 5873, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatASinPiINTEL", + .opcode = 5874, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatACosINTEL", + .opcode = 5875, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatACosPiINTEL", + .opcode = 5876, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatATanINTEL", + .opcode = 5877, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatATanPiINTEL", + .opcode = 5878, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatATan2INTEL", + .opcode = 5879, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatPowINTEL", + .opcode = 5880, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatPowRINTEL", + .opcode = 5881, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpArbitraryFloatPowNINTEL", + .opcode = 5882, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpLoopControlINTEL", + .opcode = 5887, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpAliasDomainDeclINTEL", + .opcode = 5911, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpAliasScopeDeclINTEL", + .opcode = 5912, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "OpAliasScopeListDeclINTEL", + .opcode = 5913, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpFixedSqrtINTEL", + .opcode = 5923, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedRecipINTEL", + .opcode = 5924, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedRsqrtINTEL", + .opcode = 5925, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedSinINTEL", + .opcode = 5926, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedCosINTEL", + .opcode = 5927, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedSinCosINTEL", + .opcode = 5928, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedSinPiINTEL", + .opcode = 5929, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedCosPiINTEL", + .opcode = 5930, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedSinCosPiINTEL", + .opcode = 5931, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedLogINTEL", + .opcode = 5932, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpFixedExpINTEL", + .opcode = 5933, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "OpPtrCastToCrossWorkgroupINTEL", + .opcode = 5934, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpCrossWorkgroupCastToPtrINTEL", + .opcode = 5938, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpReadPipeBlockingINTEL", + .opcode = 5946, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpWritePipeBlockingINTEL", + .opcode = 5947, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpFPGARegINTEL", + .opcode = 5949, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetRayTMinKHR", + .opcode = 6016, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetRayFlagsKHR", + .opcode = 6017, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionTKHR", + .opcode = 6018, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionInstanceCustomIndexKHR", + .opcode = 6019, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionInstanceIdKHR", + .opcode = 6020, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionInstanceShaderBindingTableRecordOffsetKHR", + .opcode = 6021, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionGeometryIndexKHR", + .opcode = 6022, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionPrimitiveIndexKHR", + .opcode = 6023, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionBarycentricsKHR", + .opcode = 6024, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionFrontFaceKHR", + .opcode = 6025, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionCandidateAABBOpaqueKHR", + .opcode = 6026, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionObjectRayDirectionKHR", + .opcode = 6027, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionObjectRayOriginKHR", + .opcode = 6028, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetWorldRayDirectionKHR", + .opcode = 6029, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetWorldRayOriginKHR", + .opcode = 6030, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionObjectToWorldKHR", + .opcode = 6031, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpRayQueryGetIntersectionWorldToObjectKHR", + .opcode = 6032, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpAtomicFAddEXT", + .opcode = 6035, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeBufferSurfaceINTEL", + .opcode = 6086, + .operands = &[_]Operand{ + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .AccessQualifier, .quantifier = .required }, + }, + }, + .{ + .name = "OpTypeStructContinuedINTEL", + .opcode = 6090, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpConstantCompositeContinuedINTEL", + .opcode = 6091, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpSpecConstantCompositeContinuedINTEL", + .opcode = 6092, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpCompositeConstructContinuedINTEL", + .opcode = 6096, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "OpConvertFToBF16INTEL", + .opcode = 6116, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpConvertBF16ToFINTEL", + .opcode = 6117, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpControlBarrierArriveINTEL", + .opcode = 6142, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpControlBarrierWaitINTEL", + .opcode = 6143, + .operands = &[_]Operand{ + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .IdMemorySemantics, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupIMulKHR", + .opcode = 6401, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupFMulKHR", + .opcode = 6402, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupBitwiseAndKHR", + .opcode = 6403, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupBitwiseOrKHR", + .opcode = 6404, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupBitwiseXorKHR", + .opcode = 6405, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupLogicalAndKHR", + .opcode = 6406, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupLogicalOrKHR", + .opcode = 6407, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpGroupLogicalXorKHR", + .opcode = 6408, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdScope, .quantifier = .required }, + .{ .kind = .GroupOperation, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMaskedGatherINTEL", + .opcode = 6428, + .operands = &[_]Operand{ + .{ .kind = .IdResultType, .quantifier = .required }, + .{ .kind = .IdResult, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "OpMaskedScatterINTEL", + .opcode = 6429, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"OpenCL.std" => &[_]Instruction{ + .{ + .name = "acos", + .opcode = 0, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "acosh", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "acospi", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "asin", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "asinh", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "asinpi", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "atan", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "atan2", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "atanh", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "atanpi", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "atan2pi", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "cbrt", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ceil", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "copysign", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "cos", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "cosh", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "cospi", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "erfc", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "erf", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "exp", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "exp2", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "exp10", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "expm1", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fabs", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fdim", + .opcode = 24, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "floor", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fma", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fmax", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fmin", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fmod", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fract", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "frexp", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "hypot", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ilogb", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ldexp", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "lgamma", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "lgamma_r", + .opcode = 36, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "log", + .opcode = 37, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "log2", + .opcode = 38, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "log10", + .opcode = 39, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "log1p", + .opcode = 40, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "logb", + .opcode = 41, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "mad", + .opcode = 42, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "maxmag", + .opcode = 43, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "minmag", + .opcode = 44, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "modf", + .opcode = 45, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "nan", + .opcode = 46, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "nextafter", + .opcode = 47, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "pow", + .opcode = 48, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "pown", + .opcode = 49, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "powr", + .opcode = 50, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "remainder", + .opcode = 51, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "remquo", + .opcode = 52, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "rint", + .opcode = 53, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "rootn", + .opcode = 54, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "round", + .opcode = 55, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "rsqrt", + .opcode = 56, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sin", + .opcode = 57, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sincos", + .opcode = 58, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sinh", + .opcode = 59, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sinpi", + .opcode = 60, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sqrt", + .opcode = 61, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "tan", + .opcode = 62, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "tanh", + .opcode = 63, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "tanpi", + .opcode = 64, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "tgamma", + .opcode = 65, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "trunc", + .opcode = 66, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_cos", + .opcode = 67, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_divide", + .opcode = 68, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_exp", + .opcode = 69, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_exp2", + .opcode = 70, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_exp10", + .opcode = 71, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_log", + .opcode = 72, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_log2", + .opcode = 73, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_log10", + .opcode = 74, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_powr", + .opcode = 75, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_recip", + .opcode = 76, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_rsqrt", + .opcode = 77, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_sin", + .opcode = 78, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_sqrt", + .opcode = 79, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "half_tan", + .opcode = 80, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_cos", + .opcode = 81, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_divide", + .opcode = 82, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_exp", + .opcode = 83, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_exp2", + .opcode = 84, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_exp10", + .opcode = 85, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_log", + .opcode = 86, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_log2", + .opcode = 87, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_log10", + .opcode = 88, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_powr", + .opcode = 89, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_recip", + .opcode = 90, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_rsqrt", + .opcode = 91, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_sin", + .opcode = 92, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_sqrt", + .opcode = 93, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "native_tan", + .opcode = 94, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fclamp", + .opcode = 95, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "degrees", + .opcode = 96, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fmax_common", + .opcode = 97, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fmin_common", + .opcode = 98, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "mix", + .opcode = 99, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "radians", + .opcode = 100, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "step", + .opcode = 101, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "smoothstep", + .opcode = 102, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "sign", + .opcode = 103, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "cross", + .opcode = 104, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "distance", + .opcode = 105, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "length", + .opcode = 106, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "normalize", + .opcode = 107, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fast_distance", + .opcode = 108, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fast_length", + .opcode = 109, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "fast_normalize", + .opcode = 110, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_abs", + .opcode = 141, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_abs_diff", + .opcode = 142, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_add_sat", + .opcode = 143, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_add_sat", + .opcode = 144, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_hadd", + .opcode = 145, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_hadd", + .opcode = 146, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_rhadd", + .opcode = 147, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_rhadd", + .opcode = 148, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_clamp", + .opcode = 149, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_clamp", + .opcode = 150, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "clz", + .opcode = 151, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ctz", + .opcode = 152, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_mad_hi", + .opcode = 153, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_mad_sat", + .opcode = 154, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_mad_sat", + .opcode = 155, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_max", + .opcode = 156, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_max", + .opcode = 157, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_min", + .opcode = 158, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_min", + .opcode = 159, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_mul_hi", + .opcode = 160, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "rotate", + .opcode = 161, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_sub_sat", + .opcode = 162, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_sub_sat", + .opcode = 163, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_upsample", + .opcode = 164, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_upsample", + .opcode = 165, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "popcount", + .opcode = 166, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_mad24", + .opcode = 167, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_mad24", + .opcode = 168, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "s_mul24", + .opcode = 169, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_mul24", + .opcode = 170, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vloadn", + .opcode = 171, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "vstoren", + .opcode = 172, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vload_half", + .opcode = 173, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vload_halfn", + .opcode = 174, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "vstore_half", + .opcode = 175, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vstore_half_r", + .opcode = 176, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .FPRoundingMode, .quantifier = .required }, + }, + }, + .{ + .name = "vstore_halfn", + .opcode = 177, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vstore_halfn_r", + .opcode = 178, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .FPRoundingMode, .quantifier = .required }, + }, + }, + .{ + .name = "vloada_halfn", + .opcode = 179, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "vstorea_halfn", + .opcode = 180, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "vstorea_halfn_r", + .opcode = 181, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .FPRoundingMode, .quantifier = .required }, + }, + }, + .{ + .name = "shuffle", + .opcode = 182, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "shuffle2", + .opcode = 183, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "printf", + .opcode = 184, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "prefetch", + .opcode = 185, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "bitselect", + .opcode = 186, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "select", + .opcode = 187, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_abs", + .opcode = 201, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_abs_diff", + .opcode = 202, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_mul_hi", + .opcode = 203, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "u_mad_hi", + .opcode = 204, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"GLSL.std.450" => &[_]Instruction{ + .{ + .name = "Round", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "RoundEven", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Trunc", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FAbs", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SAbs", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FSign", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SSign", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Floor", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Ceil", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Fract", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Radians", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Degrees", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Sin", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Cos", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Tan", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Asin", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Acos", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Atan", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Sinh", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Cosh", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Tanh", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Asinh", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Acosh", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Atanh", + .opcode = 24, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Atan2", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Pow", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Exp", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Log", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Exp2", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Log2", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Sqrt", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "InverseSqrt", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Determinant", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "MatrixInverse", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Modf", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ModfStruct", + .opcode = 36, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FMin", + .opcode = 37, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UMin", + .opcode = 38, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SMin", + .opcode = 39, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FMax", + .opcode = 40, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UMax", + .opcode = 41, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SMax", + .opcode = 42, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FClamp", + .opcode = 43, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UClamp", + .opcode = 44, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SClamp", + .opcode = 45, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FMix", + .opcode = 46, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "IMix", + .opcode = 47, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Step", + .opcode = 48, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SmoothStep", + .opcode = 49, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Fma", + .opcode = 50, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Frexp", + .opcode = 51, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FrexpStruct", + .opcode = 52, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Ldexp", + .opcode = 53, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackSnorm4x8", + .opcode = 54, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackUnorm4x8", + .opcode = 55, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackSnorm2x16", + .opcode = 56, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackUnorm2x16", + .opcode = 57, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackHalf2x16", + .opcode = 58, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PackDouble2x32", + .opcode = 59, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackSnorm2x16", + .opcode = 60, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackUnorm2x16", + .opcode = 61, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackHalf2x16", + .opcode = 62, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackSnorm4x8", + .opcode = 63, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackUnorm4x8", + .opcode = 64, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UnpackDouble2x32", + .opcode = 65, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Length", + .opcode = 66, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Distance", + .opcode = 67, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Cross", + .opcode = 68, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Normalize", + .opcode = 69, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FaceForward", + .opcode = 70, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Reflect", + .opcode = 71, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "Refract", + .opcode = 72, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FindILsb", + .opcode = 73, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FindSMsb", + .opcode = 74, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FindUMsb", + .opcode = 75, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "InterpolateAtCentroid", + .opcode = 76, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "InterpolateAtSample", + .opcode = 77, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "InterpolateAtOffset", + .opcode = 78, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "NMin", + .opcode = 79, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "NMax", + .opcode = 80, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "NClamp", + .opcode = 81, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"OpenCL.DebugInfo.100" => &[_]Instruction{ + .{ + .name = "DebugInfoNone", + .opcode = 0, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugCompilationUnit", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .SourceLanguage, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeBasic", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePointer", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeQualifier", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugTypeQualifier", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeArray", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeVector", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypedef", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeFunction", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeEnum", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeComposite", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugCompositeType", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeMember", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugTypeInheritance", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePtrToMember", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplate", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeTemplateParameter", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateTemplateParameter", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateParameterPack", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugGlobalVariable", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugFunctionDeclaration", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugFunction", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlock", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlockDiscriminator", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugScope", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugNoScope", + .opcode = 24, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugInlinedAt", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLocalVariable", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugInlinedVariable", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugDeclare", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugValue", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugOperation", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .@"OpenCL.DebugInfo.100.DebugOperation", .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugExpression", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugMacroDef", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugMacroUndef", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugImportedEntity", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"OpenCL.DebugInfo.100.DebugImportedEntity", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugSource", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugModuleINTEL", + .opcode = 36, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + }, + .SPV_AMD_shader_ballot => &[_]Instruction{ + .{ + .name = "SwizzleInvocationsAMD", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SwizzleInvocationsMaskedAMD", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "WriteInvocationAMD", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "MbcntAMD", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"NonSemantic.Shader.DebugInfo.100" => &[_]Instruction{ + .{ + .name = "DebugInfoNone", + .opcode = 0, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugCompilationUnit", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeBasic", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePointer", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeQualifier", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeArray", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeVector", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypedef", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeFunction", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeEnum", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeComposite", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeMember", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugTypeInheritance", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePtrToMember", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplate", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeTemplateParameter", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateTemplateParameter", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateParameterPack", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugGlobalVariable", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugFunctionDeclaration", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugFunction", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlock", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlockDiscriminator", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugScope", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugNoScope", + .opcode = 24, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugInlinedAt", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLocalVariable", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugInlinedVariable", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugDeclare", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugValue", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugOperation", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugExpression", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugMacroDef", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugMacroUndef", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugImportedEntity", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugSource", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugFunctionDefinition", + .opcode = 101, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugSourceContinued", + .opcode = 102, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugLine", + .opcode = 103, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugNoLine", + .opcode = 104, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugBuildIdentifier", + .opcode = 105, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugStoragePath", + .opcode = 106, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugEntryPoint", + .opcode = 107, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeMatrix", + .opcode = 108, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"NonSemantic.VkspReflection" => &[_]Instruction{ + .{ + .name = "Configuration", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "StartCounter", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .LiteralString, .quantifier = .required }, + }, + }, + .{ + .name = "StopCounter", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstants", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralString, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "SpecializationMapEntry", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DescriptorSetBuffer", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DescriptorSetImage", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DescriptorSetSampler", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralFloat, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralFloat, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralFloat, .quantifier = .required }, + .{ .kind = .LiteralFloat, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + }, + .@"NonSemantic.ClspvReflection.6" => &[_]Instruction{ + .{ + .name = "Kernel", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentInfo", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentStorageBuffer", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentUniform", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentPodStorageBuffer", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentPodUniform", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentPodPushConstant", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentSampledImage", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentStorageImage", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentSampler", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentWorkgroup", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "SpecConstantWorkgroupSize", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SpecConstantGlobalOffset", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SpecConstantWorkDim", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantGlobalOffset", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantEnqueuedLocalSize", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantGlobalSize", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantRegionOffset", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantNumWorkgroups", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PushConstantRegionGroupOffset", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ConstantDataStorageBuffer", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ConstantDataUniform", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "LiteralSampler", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PropertyRequiredWorkgroupSize", + .opcode = 24, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SpecConstantSubgroupMaxSize", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ArgumentPointerPushConstant", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentPointerUniform", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ProgramScopeVariablesStorageBuffer", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ProgramScopeVariablePointerRelocation", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ImageArgumentInfoChannelOrderPushConstant", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ImageArgumentInfoChannelDataTypePushConstant", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ImageArgumentInfoChannelOrderUniform", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ImageArgumentInfoChannelDataTypeUniform", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ArgumentStorageTexelBuffer", + .opcode = 34, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ArgumentUniformTexelBuffer", + .opcode = 35, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "ConstantDataPointerPushConstant", + .opcode = 36, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "ProgramScopeVariablePointerPushConstant", + .opcode = 37, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PrintfInfo", + .opcode = 38, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "PrintfBufferStorageBuffer", + .opcode = 39, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "PrintfBufferPointerPushConstant", + .opcode = 40, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "NormalizedSamplerMaskPushConstant", + .opcode = 41, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .SPV_AMD_gcn_shader => &[_]Instruction{ + .{ + .name = "CubeFaceIndexAMD", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "CubeFaceCoordAMD", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "TimeAMD", + .opcode = 3, + .operands = &[_]Operand{}, + }, + }, + .SPV_AMD_shader_trinary_minmax => &[_]Instruction{ + .{ + .name = "FMin3AMD", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UMin3AMD", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SMin3AMD", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FMax3AMD", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UMax3AMD", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SMax3AMD", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "FMid3AMD", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "UMid3AMD", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "SMid3AMD", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .DebugInfo => &[_]Instruction{ + .{ + .name = "DebugInfoNone", + .opcode = 0, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugCompilationUnit", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeBasic", + .opcode = 2, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugBaseTypeAttributeEncoding", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePointer", + .opcode = 3, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .StorageClass, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeQualifier", + .opcode = 4, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugTypeQualifier", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeArray", + .opcode = 5, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeVector", + .opcode = 6, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypedef", + .opcode = 7, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeFunction", + .opcode = 8, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeEnum", + .opcode = 9, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeComposite", + .opcode = 10, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugCompositeType", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeMember", + .opcode = 11, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugTypeInheritance", + .opcode = 12, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypePtrToMember", + .opcode = 13, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplate", + .opcode = 14, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugTypeTemplateParameter", + .opcode = 15, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateTemplateParameter", + .opcode = 16, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + }, + }, + .{ + .name = "DebugTypeTemplateParameterPack", + .opcode = 17, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugGlobalVariable", + .opcode = 18, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugFunctionDeclaration", + .opcode = 19, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + }, + }, + .{ + .name = "DebugFunction", + .opcode = 20, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlock", + .opcode = 21, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLexicalBlockDiscriminator", + .opcode = 22, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugScope", + .opcode = 23, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugNoScope", + .opcode = 24, + .operands = &[_]Operand{}, + }, + .{ + .name = "DebugInlinedAt", + .opcode = 25, + .operands = &[_]Operand{ + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugLocalVariable", + .opcode = 26, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugInlinedVariable", + .opcode = 27, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugDeclare", + .opcode = 28, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + .{ + .name = "DebugValue", + .opcode = 29, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugOperation", + .opcode = 30, + .operands = &[_]Operand{ + .{ .kind = .@"DebugInfo.DebugOperation", .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugExpression", + .opcode = 31, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + .{ + .name = "DebugMacroDef", + .opcode = 32, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .optional }, + }, + }, + .{ + .name = "DebugMacroUndef", + .opcode = 33, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .LiteralInteger, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"NonSemantic.DebugPrintf" => &[_]Instruction{ + .{ + .name = "DebugPrintf", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .variadic }, + }, + }, + }, + .SPV_AMD_shader_explicit_vertex_parameter => &[_]Instruction{ + .{ + .name = "InterpolateAtVertexAMD", + .opcode = 1, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + .@"NonSemantic.DebugBreak" => &[_]Instruction{ + .{ + .name = "DebugBreak", + .opcode = 1, + .operands = &[_]Operand{}, + }, + }, + .zig => &[_]Instruction{ + .{ + .name = "InvocationGlobal", + .opcode = 0, + .operands = &[_]Operand{ + .{ .kind = .IdRef, .quantifier = .required }, + }, + }, + }, + }; + } +}; diff --git a/src/link/SpirV.zig b/src/link/SpirV.zig index fae53936f670..27172c3fd30c 100644 --- a/src/link/SpirV.zig +++ b/src/link/SpirV.zig @@ -39,8 +39,12 @@ const Liveness = @import("../Liveness.zig"); const Value = @import("../Value.zig"); const SpvModule = @import("../codegen/spirv/Module.zig"); +const Section = @import("../codegen/spirv/Section.zig"); const spec = @import("../codegen/spirv/spec.zig"); const IdResult = spec.IdResult; +const Word = spec.Word; + +const BinaryModule = @import("SpirV/BinaryModule.zig"); base: link.File, @@ -163,7 +167,8 @@ pub fn updateExports( .Vertex => spec.ExecutionModel.Vertex, .Fragment => spec.ExecutionModel.Fragment, .Kernel => spec.ExecutionModel.Kernel, - else => return, + .C => return, // TODO: What to do here? + else => unreachable, }; const is_vulkan = target.os.tag == .vulkan; @@ -197,8 +202,6 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node @panic("Attempted to compile for architecture that was disabled by build configuration"); } - _ = arena; // Has the same lifetime as the call to Compilation.update. - const tracy = trace(@src()); defer tracy.end(); @@ -223,9 +226,9 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node defer error_info.deinit(); try error_info.appendSlice("zig_errors"); - const module = self.base.comp.module.?; - for (module.global_error_set.keys()) |name_nts| { - const name = module.intern_pool.stringToSlice(name_nts); + const mod = self.base.comp.module.?; + for (mod.global_error_set.keys()) |name_nts| { + const name = mod.intern_pool.stringToSlice(name_nts); // Errors can contain pretty much any character - to encode them in a string we must escape // them somehow. Easiest here is to use some established scheme, one which also preseves the // name if it contains no strange characters is nice for debugging. URI encoding fits the bill. @@ -239,7 +242,34 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node .extension = error_info.items, }); - try spv.flush(self.base.file.?, target); + const module = try spv.finalize(arena, target); + errdefer arena.free(module); + + const linked_module = self.linkModule(arena, module) catch |err| switch (err) { + error.OutOfMemory => return error.OutOfMemory, + else => |other| { + log.err("error while linking: {s}\n", .{@errorName(other)}); + return error.FlushFailure; + }, + }; + + try self.base.file.?.writeAll(std.mem.sliceAsBytes(linked_module)); +} + +fn linkModule(self: *SpirV, a: Allocator, module: []Word) ![]Word { + _ = self; + + const lower_invocation_globals = @import("SpirV/lower_invocation_globals.zig"); + const prune_unused = @import("SpirV/prune_unused.zig"); + + var parser = try BinaryModule.Parser.init(a); + defer parser.deinit(); + var binary = try parser.parse(module); + + try lower_invocation_globals.run(&parser, &binary); + try prune_unused.run(&parser, &binary); + + return binary.finalize(a); } fn writeCapabilities(spv: *SpvModule, target: std.Target) !void { diff --git a/src/link/SpirV/BinaryModule.zig b/src/link/SpirV/BinaryModule.zig new file mode 100644 index 000000000000..0c9c32c98e04 --- /dev/null +++ b/src/link/SpirV/BinaryModule.zig @@ -0,0 +1,461 @@ +const std = @import("std"); +const assert = std.debug.assert; +const Allocator = std.mem.Allocator; +const log = std.log.scoped(.spirv_parse); + +const spec = @import("../../codegen/spirv/spec.zig"); +const Opcode = spec.Opcode; +const Word = spec.Word; +const InstructionSet = spec.InstructionSet; +const ResultId = spec.IdResult; + +const BinaryModule = @This(); + +pub const header_words = 5; + +/// The module SPIR-V version. +version: spec.Version, + +/// The generator magic number. +generator_magic: u32, + +/// The result-id bound of this SPIR-V module. +id_bound: u32, + +/// The instructions of this module. This does not contain the header. +instructions: []const Word, + +/// Maps OpExtInstImport result-ids to their InstructionSet. +ext_inst_map: std.AutoHashMapUnmanaged(ResultId, InstructionSet), + +/// This map contains the width of arithmetic types (OpTypeInt and +/// OpTypeFloat). We need this information to correctly parse the operands +/// of Op(Spec)Constant and OpSwitch. +arith_type_width: std.AutoHashMapUnmanaged(ResultId, u16), + +/// The starting offsets of some sections +sections: struct { + functions: usize, +}, + +pub fn deinit(self: *BinaryModule, a: Allocator) void { + self.ext_inst_map.deinit(a); + self.arith_type_width.deinit(a); + self.* = undefined; +} + +pub fn iterateInstructions(self: BinaryModule) Instruction.Iterator { + return Instruction.Iterator.init(self.instructions, 0); +} + +pub fn iterateInstructionsFrom(self: BinaryModule, offset: usize) Instruction.Iterator { + return Instruction.Iterator.init(self.instructions, offset); +} + +pub fn instructionAt(self: BinaryModule, offset: usize) Instruction { + var it = self.iterateInstructionsFrom(offset); + return it.next().?; +} + +pub fn finalize(self: BinaryModule, a: Allocator) ![]Word { + const result = try a.alloc(Word, 5 + self.instructions.len); + errdefer a.free(result); + + result[0] = spec.magic_number; + result[1] = @bitCast(self.version); + result[2] = spec.zig_generator_id; + result[3] = self.id_bound; + result[4] = 0; // Schema + + @memcpy(result[5..], self.instructions); + return result; +} + +/// Errors that can be raised when the module is not correct. +/// Note that the parser doesn't validate SPIR-V modules by a +/// long shot. It only yields errors that critically prevent +/// further analysis of the module. +pub const ParseError = error{ + /// Raised when the module doesn't start with the SPIR-V magic. + /// This usually means that the module isn't actually SPIR-V. + InvalidMagic, + /// Raised when the module has an invalid "physical" format: + /// For example when the header is incomplete, or an instruction + /// has an illegal format. + InvalidPhysicalFormat, + /// OpExtInstImport was used with an unknown extension string. + InvalidExtInstImport, + /// The module had an instruction with an invalid (unknown) opcode. + InvalidOpcode, + /// An instruction's operands did not conform to the SPIR-V specification + /// for that instruction. + InvalidOperands, + /// A result-id was declared more than once. + DuplicateId, + /// Some ID did not resolve. + InvalidId, + /// Parser ran out of memory. + OutOfMemory, +}; + +pub const Instruction = struct { + pub const Iterator = struct { + words: []const Word, + index: usize = 0, + offset: usize = 0, + + pub fn init(words: []const Word, start_offset: usize) Iterator { + return .{ .words = words, .offset = start_offset }; + } + + pub fn next(self: *Iterator) ?Instruction { + if (self.offset >= self.words.len) return null; + + const instruction_len = self.words[self.offset] >> 16; + defer self.offset += instruction_len; + defer self.index += 1; + assert(instruction_len != 0 and self.offset < self.words.len); // Verified in BinaryModule.parse. + + return Instruction{ + .opcode = @enumFromInt(self.words[self.offset] & 0xFFFF), + .index = self.index, + .offset = self.offset, + .operands = self.words[self.offset..][1..instruction_len], + }; + } + }; + + /// The opcode for this instruction. + opcode: Opcode, + /// The instruction's index. + index: usize, + /// The instruction's word offset in the module. + offset: usize, + /// The raw (unparsed) operands for this instruction. + operands: []const Word, +}; + +/// This parser contains information (acceleration tables) +/// that can be persisted across different modules. This is +/// used to initialize the module, and is also used when +/// further analyzing it. +pub const Parser = struct { + /// The allocator used to allocate this parser's structures, + /// and also the structures of any parsed module. + a: Allocator, + + /// Maps (instruction set, opcode) => instruction index (for instruction set) + opcode_table: std.AutoHashMapUnmanaged(u32, u16) = .{}, + + pub fn init(a: Allocator) !Parser { + var self = Parser{ + .a = a, + }; + errdefer self.deinit(); + + inline for (std.meta.tags(InstructionSet)) |set| { + const instructions = set.instructions(); + try self.opcode_table.ensureUnusedCapacity(a, @intCast(instructions.len)); + for (instructions, 0..) |inst, i| { + // Note: Some instructions may alias another. In this case we don't really care + // which one is first: they all (should) have the same operands anyway. Just pick + // the first, which is usually the core, KHR or EXT variant. + const entry = self.opcode_table.getOrPutAssumeCapacity(mapSetAndOpcode(set, @intCast(inst.opcode))); + if (!entry.found_existing) { + entry.value_ptr.* = @intCast(i); + } + } + } + + return self; + } + + pub fn deinit(self: *Parser) void { + self.opcode_table.deinit(self.a); + } + + fn mapSetAndOpcode(set: InstructionSet, opcode: u16) u32 { + return (@as(u32, @intFromEnum(set)) << 16) | opcode; + } + + pub fn getInstSpec(self: Parser, opcode: Opcode) ?spec.Instruction { + const index = self.opcode_table.get(mapSetAndOpcode(.core, @intFromEnum(opcode))) orelse return null; + return InstructionSet.core.instructions()[index]; + } + + pub fn parse(self: *Parser, module: []const u32) ParseError!BinaryModule { + if (module[0] != spec.magic_number) { + return error.InvalidMagic; + } else if (module.len < header_words) { + log.err("module only has {}/{} header words", .{ module.len, header_words }); + return error.InvalidPhysicalFormat; + } + + var binary = BinaryModule{ + .version = @bitCast(module[1]), + .generator_magic = module[2], + .id_bound = module[3], + .instructions = module[header_words..], + .ext_inst_map = .{}, + .arith_type_width = .{}, + .sections = undefined, + }; + + var maybe_function_section: ?usize = null; + + // First pass through the module to verify basic structure and + // to gather some initial stuff for more detailed analysis. + // We want to check some stuff that Instruction.Iterator is no good for, + // so just iterate manually. + var offset: usize = 0; + while (offset < binary.instructions.len) { + const len = binary.instructions[offset] >> 16; + if (len == 0 or len + offset > binary.instructions.len) { + log.err("invalid instruction format: len={}, end={}, module len={}", .{ len, len + offset, binary.instructions.len }); + return error.InvalidPhysicalFormat; + } + defer offset += len; + + // We can't really efficiently use non-exhaustive enums here, because we would + // need to manually write out all valid cases. Since we have this map anyway, just + // use that. + const opcode: Opcode = @enumFromInt(@as(u16, @truncate(binary.instructions[offset]))); + const inst_spec = self.getInstSpec(opcode) orelse { + log.err("invalid opcode for core set: {}", .{@intFromEnum(opcode)}); + return error.InvalidOpcode; + }; + + const operands = binary.instructions[offset..][1..len]; + switch (opcode) { + .OpExtInstImport => { + const set_name = std.mem.sliceTo(std.mem.sliceAsBytes(operands[1..]), 0); + const set = std.meta.stringToEnum(InstructionSet, set_name) orelse { + log.err("invalid instruction set '{s}'", .{set_name}); + return error.InvalidExtInstImport; + }; + if (set == .core) return error.InvalidExtInstImport; + try binary.ext_inst_map.put(self.a, @enumFromInt(operands[0]), set); + }, + .OpTypeInt, .OpTypeFloat => { + const entry = try binary.arith_type_width.getOrPut(self.a, @enumFromInt(operands[0])); + if (entry.found_existing) return error.DuplicateId; + entry.value_ptr.* = std.math.cast(u16, operands[1]) orelse return error.InvalidOperands; + }, + .OpFunction => if (maybe_function_section == null) { + maybe_function_section = offset; + }, + else => {}, + } + + // OpSwitch takes a value as argument, not an OpType... hence we need to populate arith_type_width + // with ALL operations that return an int or float. + const spec_operands = inst_spec.operands; + if (spec_operands.len >= 2 and + spec_operands[0].kind == .IdResultType and + spec_operands[1].kind == .IdResult) + { + if (operands.len < 2) return error.InvalidOperands; + if (binary.arith_type_width.get(@enumFromInt(operands[0]))) |width| { + const entry = try binary.arith_type_width.getOrPut(self.a, @enumFromInt(operands[1])); + if (entry.found_existing) return error.DuplicateId; + entry.value_ptr.* = width; + } + } + } + + binary.sections = .{ + .functions = maybe_function_section orelse binary.instructions.len, + }; + + return binary; + } + + /// Parse offsets in the instruction that contain result-ids. + /// Returned offsets are relative to inst.operands. + /// Returns in an arraylist to armortize allocations. + pub fn parseInstructionResultIds( + self: *Parser, + binary: BinaryModule, + inst: Instruction, + offsets: *std.ArrayList(u16), + ) !void { + const index = self.opcode_table.get(mapSetAndOpcode(.core, @intFromEnum(inst.opcode))).?; + const operands = InstructionSet.core.instructions()[index].operands; + + var offset: usize = 0; + switch (inst.opcode) { + .OpSpecConstantOp => { + assert(operands[0].kind == .IdResultType); + assert(operands[1].kind == .IdResult); + offset = try self.parseOperandsResultIds(binary, inst, operands[0..2], offset, offsets); + + if (offset >= inst.operands.len) return error.InvalidPhysicalFormat; + const spec_opcode = std.math.cast(u16, inst.operands[offset]) orelse return error.InvalidPhysicalFormat; + const spec_index = self.opcode_table.get(mapSetAndOpcode(.core, spec_opcode)) orelse + return error.InvalidPhysicalFormat; + const spec_operands = InstructionSet.core.instructions()[spec_index].operands; + assert(spec_operands[0].kind == .IdResultType); + assert(spec_operands[1].kind == .IdResult); + offset = try self.parseOperandsResultIds(binary, inst, spec_operands[2..], offset + 1, offsets); + }, + .OpExtInst => { + assert(operands[0].kind == .IdResultType); + assert(operands[1].kind == .IdResult); + offset = try self.parseOperandsResultIds(binary, inst, operands[0..2], offset, offsets); + + if (offset + 1 >= inst.operands.len) return error.InvalidPhysicalFormat; + const set_id: ResultId = @enumFromInt(inst.operands[offset]); + try offsets.append(@intCast(offset)); + const set = binary.ext_inst_map.get(set_id) orelse { + log.err("invalid instruction set {}", .{@intFromEnum(set_id)}); + return error.InvalidId; + }; + const ext_opcode = std.math.cast(u16, inst.operands[offset + 1]) orelse return error.InvalidPhysicalFormat; + const ext_index = self.opcode_table.get(mapSetAndOpcode(set, ext_opcode)) orelse + return error.InvalidPhysicalFormat; + const ext_operands = set.instructions()[ext_index].operands; + offset = try self.parseOperandsResultIds(binary, inst, ext_operands, offset + 2, offsets); + }, + else => { + offset = try self.parseOperandsResultIds(binary, inst, operands, offset, offsets); + }, + } + + if (offset != inst.operands.len) return error.InvalidPhysicalFormat; + } + + fn parseOperandsResultIds( + self: *Parser, + binary: BinaryModule, + inst: Instruction, + operands: []const spec.Operand, + start_offset: usize, + offsets: *std.ArrayList(u16), + ) !usize { + var offset = start_offset; + for (operands) |operand| { + offset = try self.parseOperandResultIds(binary, inst, operand, offset, offsets); + } + return offset; + } + + fn parseOperandResultIds( + self: *Parser, + binary: BinaryModule, + inst: Instruction, + operand: spec.Operand, + start_offset: usize, + offsets: *std.ArrayList(u16), + ) !usize { + var offset = start_offset; + switch (operand.quantifier) { + .variadic => while (offset < inst.operands.len) { + offset = try self.parseOperandKindResultIds(binary, inst, operand.kind, offset, offsets); + }, + .optional => if (offset < inst.operands.len) { + offset = try self.parseOperandKindResultIds(binary, inst, operand.kind, offset, offsets); + }, + .required => { + offset = try self.parseOperandKindResultIds(binary, inst, operand.kind, offset, offsets); + }, + } + return offset; + } + + fn parseOperandKindResultIds( + self: *Parser, + binary: BinaryModule, + inst: Instruction, + kind: spec.OperandKind, + start_offset: usize, + offsets: *std.ArrayList(u16), + ) !usize { + var offset = start_offset; + if (offset >= inst.operands.len) return error.InvalidPhysicalFormat; + + switch (kind.category()) { + .bit_enum => { + const mask = inst.operands[offset]; + offset += 1; + for (kind.enumerants()) |enumerant| { + if ((mask & enumerant.value) != 0) { + for (enumerant.parameters) |param_kind| { + offset = try self.parseOperandKindResultIds(binary, inst, param_kind, offset, offsets); + } + } + } + }, + .value_enum => { + const value = inst.operands[offset]; + offset += 1; + for (kind.enumerants()) |enumerant| { + if (value == enumerant.value) { + for (enumerant.parameters) |param_kind| { + offset = try self.parseOperandKindResultIds(binary, inst, param_kind, offset, offsets); + } + break; + } + } + }, + .id => { + try offsets.append(@intCast(offset)); + offset += 1; + }, + else => switch (kind) { + .LiteralInteger, .LiteralFloat => offset += 1, + .LiteralString => while (true) { + if (offset >= inst.operands.len) return error.InvalidPhysicalFormat; + const word = inst.operands[offset]; + offset += 1; + + if (word & 0xFF000000 == 0 or + word & 0x00FF0000 == 0 or + word & 0x0000FF00 == 0 or + word & 0x000000FF == 0) + { + break; + } + }, + .LiteralContextDependentNumber => { + assert(inst.opcode == .OpConstant or inst.opcode == .OpSpecConstantOp); + const bit_width = binary.arith_type_width.get(@enumFromInt(inst.operands[0])) orelse { + log.err("invalid LiteralContextDependentNumber type {}", .{inst.operands[0]}); + return error.InvalidId; + }; + offset += switch (bit_width) { + 1...32 => 1, + 33...64 => 2, + else => unreachable, + }; + }, + .LiteralExtInstInteger => unreachable, + .LiteralSpecConstantOpInteger => unreachable, + .PairLiteralIntegerIdRef => { // Switch case + assert(inst.opcode == .OpSwitch); + const bit_width = binary.arith_type_width.get(@enumFromInt(inst.operands[0])) orelse { + log.err("invalid OpSwitch type {}", .{inst.operands[0]}); + return error.InvalidId; + }; + offset += switch (bit_width) { + 1...32 => 1, + 33...64 => 2, + else => unreachable, + }; + try offsets.append(@intCast(offset)); + offset += 1; + }, + .PairIdRefLiteralInteger => { + try offsets.append(@intCast(offset)); + offset += 2; + }, + .PairIdRefIdRef => { + try offsets.append(@intCast(offset)); + try offsets.append(@intCast(offset + 1)); + offset += 2; + }, + else => unreachable, + }, + } + return offset; + } +}; diff --git a/src/link/SpirV/lower_invocation_globals.zig b/src/link/SpirV/lower_invocation_globals.zig new file mode 100644 index 000000000000..e6de48ff93e0 --- /dev/null +++ b/src/link/SpirV/lower_invocation_globals.zig @@ -0,0 +1,700 @@ +const std = @import("std"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const log = std.log.scoped(.spirv_link); + +const BinaryModule = @import("BinaryModule.zig"); +const Section = @import("../../codegen/spirv/Section.zig"); +const spec = @import("../../codegen/spirv/spec.zig"); +const ResultId = spec.IdResult; +const Word = spec.Word; + +/// This structure contains all the stuff that we need to parse from the module in +/// order to run this pass, as well as some functions to ease its use. +const ModuleInfo = struct { + /// Information about a particular function. + const Fn = struct { + /// The index of the first callee in `callee_store`. + first_callee: usize, + /// The return type id of this function + return_type: ResultId, + /// The parameter types of this function + param_types: []const ResultId, + /// The set of (result-id's of) invocation globals that are accessed + /// in this function, or after resolution, that are accessed in this + /// function or any of it's callees. + invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, void), + }; + + /// Information about a particular invocation global + const InvocationGlobal = struct { + /// The list of invocation globals that this invocation global + /// depends on. + dependencies: std.AutoArrayHashMapUnmanaged(ResultId, void), + /// The invocation global's type + ty: ResultId, + /// Initializer function. May be `none`. + /// Note that if the initializer is `none`, then `dependencies` is empty. + initializer: ResultId, + }; + + /// Maps function result-id -> Fn information structure. + functions: std.AutoArrayHashMapUnmanaged(ResultId, Fn), + /// Set of OpFunction result-ids in this module. + entry_points: std.AutoArrayHashMapUnmanaged(ResultId, void), + /// For each function, a list of function result-ids that it calls. + callee_store: []const ResultId, + /// Maps each invocation global result-id to a type-id. + invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, InvocationGlobal), + + /// Fetch the list of callees per function. Guaranteed to contain only unique IDs. + fn callees(self: ModuleInfo, fn_id: ResultId) []const ResultId { + const fn_index = self.functions.getIndex(fn_id).?; + const values = self.functions.values(); + const first_callee = values[fn_index].first_callee; + if (fn_index == values.len - 1) { + return self.callee_store[first_callee..]; + } else { + const next_first_callee = values[fn_index + 1].first_callee; + return self.callee_store[first_callee..next_first_callee]; + } + } + + /// Extract most of the required information from the binary. The remaining info is + /// constructed by `resolve()`. + fn parse( + arena: Allocator, + parser: *BinaryModule.Parser, + binary: BinaryModule, + ) BinaryModule.ParseError!ModuleInfo { + var entry_points = std.AutoArrayHashMap(ResultId, void).init(arena); + var functions = std.AutoArrayHashMap(ResultId, Fn).init(arena); + var fn_types = std.AutoHashMap(ResultId, struct { + return_type: ResultId, + param_types: []const ResultId, + }).init(arena); + var calls = std.AutoArrayHashMap(ResultId, void).init(arena); + var callee_store = std.ArrayList(ResultId).init(arena); + var function_invocation_globals = std.AutoArrayHashMap(ResultId, void).init(arena); + var result_id_offsets = std.ArrayList(u16).init(arena); + var invocation_globals = std.AutoArrayHashMap(ResultId, InvocationGlobal).init(arena); + + var maybe_current_function: ?ResultId = null; + var fn_ty_id: ResultId = undefined; + + var it = binary.iterateInstructions(); + while (it.next()) |inst| { + result_id_offsets.items.len = 0; + try parser.parseInstructionResultIds(binary, inst, &result_id_offsets); + + switch (inst.opcode) { + .OpEntryPoint => { + const entry_point: ResultId = @enumFromInt(inst.operands[1]); + const entry = try entry_points.getOrPut(entry_point); + if (entry.found_existing) { + log.err("Entry point type {} has duplicate definition", .{entry_point}); + return error.DuplicateId; + } + }, + .OpTypeFunction => { + const fn_type: ResultId = @enumFromInt(inst.operands[0]); + const return_type: ResultId = @enumFromInt(inst.operands[1]); + const param_types: []const ResultId = @ptrCast(inst.operands[2..]); + + const entry = try fn_types.getOrPut(fn_type); + if (entry.found_existing) { + log.err("Function type {} has duplicate definition", .{fn_type}); + return error.DuplicateId; + } + + entry.value_ptr.* = .{ + .return_type = return_type, + .param_types = param_types, + }; + }, + .OpExtInst => { + // Note: format and set are already verified by parseInstructionResultIds(). + const global_type: ResultId = @enumFromInt(inst.operands[0]); + const result_id: ResultId = @enumFromInt(inst.operands[1]); + const set_id: ResultId = @enumFromInt(inst.operands[2]); + const set_inst = inst.operands[3]; + + const set = binary.ext_inst_map.get(set_id).?; + if (set == .zig and set_inst == 0) { + const initializer: ResultId = if (inst.operands.len >= 5) + @enumFromInt(inst.operands[4]) + else + .none; + + try invocation_globals.put(result_id, .{ + .dependencies = .{}, + .ty = global_type, + .initializer = initializer, + }); + } + }, + .OpFunction => { + if (maybe_current_function) |current_function| { + log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function}); + return error.InvalidPhysicalFormat; + } + + maybe_current_function = @enumFromInt(inst.operands[1]); + fn_ty_id = @enumFromInt(inst.operands[3]); + function_invocation_globals.clearRetainingCapacity(); + }, + .OpFunctionCall => { + const callee: ResultId = @enumFromInt(inst.operands[2]); + try calls.put(callee, {}); + }, + .OpFunctionEnd => { + const current_function = maybe_current_function orelse { + log.err("encountered OpFunctionEnd without corresponding OpFunction", .{}); + return error.InvalidPhysicalFormat; + }; + const entry = try functions.getOrPut(current_function); + if (entry.found_existing) { + log.err("Function {} has duplicate definition", .{current_function}); + return error.DuplicateId; + } + + const first_callee = callee_store.items.len; + try callee_store.appendSlice(calls.keys()); + + const fn_type = fn_types.get(fn_ty_id) orelse { + log.err("Function {} has invalid OpFunction type", .{current_function}); + return error.InvalidId; + }; + + entry.value_ptr.* = .{ + .first_callee = first_callee, + .return_type = fn_type.return_type, + .param_types = fn_type.param_types, + .invocation_globals = try function_invocation_globals.unmanaged.clone(arena), + }; + maybe_current_function = null; + calls.clearRetainingCapacity(); + }, + else => {}, + } + + for (result_id_offsets.items) |off| { + const result_id: ResultId = @enumFromInt(inst.operands[off]); + if (invocation_globals.contains(result_id)) { + try function_invocation_globals.put(result_id, {}); + } + } + } + + if (maybe_current_function) |current_function| { + log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function}); + return error.InvalidPhysicalFormat; + } + + return ModuleInfo{ + .functions = functions.unmanaged, + .entry_points = entry_points.unmanaged, + .callee_store = callee_store.items, + .invocation_globals = invocation_globals.unmanaged, + }; + } + + /// Derive the remaining info from the structures filled in by parsing. + fn resolve(self: *ModuleInfo, arena: Allocator) !void { + try self.resolveInvocationGlobalUsage(arena); + try self.resolveInvocationGlobalDependencies(arena); + } + + /// For each function, extend the list of `invocation_globals` with the + /// invocation globals that ALL of its dependencies use. + fn resolveInvocationGlobalUsage(self: *ModuleInfo, arena: Allocator) !void { + var seen = try std.DynamicBitSetUnmanaged.initEmpty(arena, self.functions.count()); + + for (self.functions.keys()) |id| { + try self.resolveInvocationGlobalUsageStep(arena, id, &seen); + } + } + + fn resolveInvocationGlobalUsageStep( + self: *ModuleInfo, + arena: Allocator, + id: ResultId, + seen: *std.DynamicBitSetUnmanaged, + ) !void { + const index = self.functions.getIndex(id) orelse { + log.err("function calls invalid function {}", .{id}); + return error.InvalidId; + }; + + if (seen.isSet(index)) { + return; + } + seen.set(index); + + const info = &self.functions.values()[index]; + for (self.callees(id)) |callee| { + try self.resolveInvocationGlobalUsageStep(arena, callee, seen); + const callee_info = self.functions.get(callee).?; + for (callee_info.invocation_globals.keys()) |global| { + try info.invocation_globals.put(arena, global, {}); + } + } + } + + /// For each invocation global, populate and fully resolve the `dependencies` set. + /// This requires `resolveInvocationGlobalUsage()` to be already done. + fn resolveInvocationGlobalDependencies( + self: *ModuleInfo, + arena: Allocator, + ) !void { + var seen = try std.DynamicBitSetUnmanaged.initEmpty(arena, self.invocation_globals.count()); + + for (self.invocation_globals.keys()) |id| { + try self.resolveInvocationGlobalDependenciesStep(arena, id, &seen); + } + } + + fn resolveInvocationGlobalDependenciesStep( + self: *ModuleInfo, + arena: Allocator, + id: ResultId, + seen: *std.DynamicBitSetUnmanaged, + ) !void { + const index = self.invocation_globals.getIndex(id) orelse { + log.err("invalid invocation global {}", .{id}); + return error.InvalidId; + }; + + if (seen.isSet(index)) { + return; + } + seen.set(index); + + const info = &self.invocation_globals.values()[index]; + if (info.initializer == .none) { + return; + } + + const initializer = self.functions.get(info.initializer) orelse { + log.err("invocation global {} has invalid initializer {}", .{ id, info.initializer }); + return error.InvalidId; + }; + + for (initializer.invocation_globals.keys()) |dependency| { + if (dependency == id) { + // The set of invocation global dependencies includes the dependency itself, + // so we need to skip that case. + continue; + } + + try info.dependencies.put(arena, dependency, {}); + try self.resolveInvocationGlobalDependenciesStep(arena, dependency, seen); + + const dep_info = self.invocation_globals.getPtr(dependency).?; + + for (dep_info.dependencies.keys()) |global| { + try info.dependencies.put(arena, global, {}); + } + } + } +}; + +const ModuleBuilder = struct { + const FunctionType = struct { + return_type: ResultId, + param_types: []const ResultId, + + const Context = struct { + pub fn hash(_: @This(), ty: FunctionType) u32 { + var hasher = std.hash.Wyhash.init(0); + hasher.update(std.mem.asBytes(&ty.return_type)); + hasher.update(std.mem.sliceAsBytes(ty.param_types)); + return @truncate(hasher.final()); + } + + pub fn eql(_: @This(), a: FunctionType, b: FunctionType, _: usize) bool { + if (a.return_type != b.return_type) return false; + return std.mem.eql(ResultId, a.param_types, b.param_types); + } + }; + }; + + const FunctionNewInfo = struct { + /// This is here just so that we don't need to allocate the new + /// param_types multiple times. + new_function_type: ResultId, + /// The first ID of the parameters for the invocation globals. + /// Each global is allocate here according to the index in + /// `ModuleInfo.Fn.invocation_globals`. + global_id_base: u32, + + fn invocationGlobalId(self: FunctionNewInfo, index: usize) ResultId { + return @enumFromInt(self.global_id_base + @as(u32, @intCast(index))); + } + }; + + arena: Allocator, + section: Section, + /// The ID bound of the new module. + id_bound: u32, + /// The first ID of the new entry points. Entry points are allocated from + /// here according to their index in `info.entry_points`. + entry_point_new_id_base: u32, + /// A set of all function types in the new program. SPIR-V mandates that these are unique, + /// and until a general type deduplication pass is programmed, we just handle it here via this. + function_types: std.ArrayHashMapUnmanaged(FunctionType, ResultId, FunctionType.Context, true) = .{}, + /// Maps functions to new information required for creating the module + function_new_info: std.AutoArrayHashMapUnmanaged(ResultId, FunctionNewInfo) = .{}, + /// Offset of the functions section in the new binary. + new_functions_section: ?usize, + + fn init(arena: Allocator, binary: BinaryModule, info: ModuleInfo) !ModuleBuilder { + var self = ModuleBuilder{ + .arena = arena, + .section = .{}, + .id_bound = binary.id_bound, + .entry_point_new_id_base = undefined, + .new_functions_section = null, + }; + self.entry_point_new_id_base = @intFromEnum(self.allocIds(@intCast(info.entry_points.count()))); + return self; + } + + fn allocId(self: *ModuleBuilder) ResultId { + return self.allocIds(1); + } + + fn allocIds(self: *ModuleBuilder, n: u32) ResultId { + defer self.id_bound += n; + return @enumFromInt(self.id_bound); + } + + fn finalize(self: *ModuleBuilder, a: Allocator, binary: *BinaryModule) !void { + binary.id_bound = self.id_bound; + binary.instructions = try a.dupe(Word, self.section.instructions.items); + // Nothing is removed in this pass so we don't need to change any of the maps, + // just make sure the section is updated. + binary.sections.functions = self.new_functions_section orelse binary.instructions.len; + } + + /// Process everything from `binary` up to the first function and emit it into the builder. + fn processPreamble(self: *ModuleBuilder, binary: BinaryModule, info: ModuleInfo) !void { + var it = binary.iterateInstructions(); + while (it.next()) |inst| { + switch (inst.opcode) { + .OpExtInst => { + const set_id: ResultId = @enumFromInt(inst.operands[2]); + const set_inst = inst.operands[3]; + const set = binary.ext_inst_map.get(set_id).?; + if (set == .zig and set_inst == 0) { + continue; + } + }, + .OpEntryPoint => { + const original_id: ResultId = @enumFromInt(inst.operands[1]); + const new_id_index = info.entry_points.getIndex(original_id).?; + const new_id: ResultId = @enumFromInt(self.entry_point_new_id_base + new_id_index); + try self.section.emitRaw(self.arena, .OpEntryPoint, inst.operands.len); + self.section.writeWord(inst.operands[0]); + self.section.writeOperand(ResultId, new_id); + self.section.writeWords(inst.operands[2..]); + continue; + }, + .OpTypeFunction => { + // Re-emitted in `emitFunctionTypes()`. We can do this because + // OpTypeFunction's may not currently be used anywhere that is not + // directly with an OpFunction. For now we igore Intels function + // pointers extension, that is not a problem with a generalized + // pass anyway. + continue; + }, + .OpFunction => break, + else => {}, + } + + try self.section.emitRawInstruction(self.arena, inst.opcode, inst.operands); + } + } + + /// Derive new information required for further emitting this module, + fn deriveNewFnInfo(self: *ModuleBuilder, info: ModuleInfo) !void { + for (info.functions.keys(), info.functions.values()) |func, fn_info| { + const invocation_global_count = fn_info.invocation_globals.count(); + const new_param_types = try self.arena.alloc(ResultId, fn_info.param_types.len + invocation_global_count); + for (fn_info.invocation_globals.keys(), 0..) |global, i| { + new_param_types[i] = info.invocation_globals.get(global).?.ty; + } + @memcpy(new_param_types[invocation_global_count..], fn_info.param_types); + + const new_type = try self.internFunctionType(fn_info.return_type, new_param_types); + try self.function_new_info.put(self.arena, func, .{ + .new_function_type = new_type, + .global_id_base = @intFromEnum(self.allocIds(@intCast(invocation_global_count))), + }); + } + } + + /// Emit the new function types, which include the parameters for the invocation globals. + /// Currently, this function re-emits ALL function types to ensure that there are + /// no duplicates in the final program. + /// TODO: The above should be resolved by a generalized deduplication pass, and then + /// we only need to emit the new function pointers type here. + fn emitFunctionTypes(self: *ModuleBuilder, info: ModuleInfo) !void { + // TODO: Handle decorators. Function types usually don't have those + // though, but stuff like OpName could be a possibility. + + // Entry points retain their old function type, so make sure to emit + // those in the `function_types` set. + for (info.entry_points.keys()) |func| { + const fn_info = info.functions.get(func).?; + _ = try self.internFunctionType(fn_info.return_type, fn_info.param_types); + } + + for (self.function_types.keys(), self.function_types.values()) |fn_type, result_id| { + try self.section.emit(self.arena, .OpTypeFunction, .{ + .id_result = result_id, + .return_type = fn_type.return_type, + .id_ref_2 = fn_type.param_types, + }); + } + } + + fn internFunctionType(self: *ModuleBuilder, return_type: ResultId, param_types: []const ResultId) !ResultId { + const entry = try self.function_types.getOrPut(self.arena, .{ + .return_type = return_type, + .param_types = param_types, + }); + + if (!entry.found_existing) { + const new_id = self.allocId(); + entry.value_ptr.* = new_id; + } + + return entry.value_ptr.*; + } + + /// Rewrite the modules' functions and emit them with the new parameter types. + fn rewriteFunctions( + self: *ModuleBuilder, + parser: *BinaryModule.Parser, + binary: BinaryModule, + info: ModuleInfo, + ) !void { + var result_id_offsets = std.ArrayList(u16).init(self.arena); + var operands = std.ArrayList(u32).init(self.arena); + + var maybe_current_function: ?ResultId = null; + var it = binary.iterateInstructionsFrom(binary.sections.functions); + self.new_functions_section = self.section.instructions.items.len; + while (it.next()) |inst| { + result_id_offsets.items.len = 0; + try parser.parseInstructionResultIds(binary, inst, &result_id_offsets); + + operands.items.len = 0; + try operands.appendSlice(inst.operands); + + // Replace the result-ids with the global's new result-id if required. + for (result_id_offsets.items) |off| { + const result_id: ResultId = @enumFromInt(operands.items[off]); + if (info.invocation_globals.contains(result_id)) { + const func = maybe_current_function.?; + const new_info = self.function_new_info.get(func).?; + const fn_info = info.functions.get(func).?; + const index = fn_info.invocation_globals.getIndex(result_id).?; + operands.items[off] = @intFromEnum(new_info.invocationGlobalId(index)); + } + } + + switch (inst.opcode) { + .OpFunction => { + // Re-declare the function with the new parameters. + const func: ResultId = @enumFromInt(operands.items[1]); + const fn_info = info.functions.get(func).?; + const new_info = self.function_new_info.get(func).?; + + try self.section.emitRaw(self.arena, .OpFunction, 4); + self.section.writeOperand(ResultId, fn_info.return_type); + self.section.writeOperand(ResultId, func); + self.section.writeWord(operands.items[2]); + self.section.writeOperand(ResultId, new_info.new_function_type); + + // Emit the OpFunctionParameters for the invocation globals. The functions + // actual parameters are emitted unchanged from their original form, so + // we don't need to handle those here. + + for (fn_info.invocation_globals.keys(), 0..) |global, index| { + const ty = info.invocation_globals.get(global).?.ty; + const id = new_info.invocationGlobalId(index); + try self.section.emit(self.arena, .OpFunctionParameter, .{ + .id_result_type = ty, + .id_result = id, + }); + } + + maybe_current_function = func; + }, + .OpFunctionCall => { + // Add the required invocation globals to the function's new parameter list. + const caller = maybe_current_function.?; + const callee: ResultId = @enumFromInt(operands.items[2]); + const caller_info = info.functions.get(caller).?; + const callee_info = info.functions.get(callee).?; + const caller_new_info = self.function_new_info.get(caller).?; + const total_params = callee_info.invocation_globals.count() + callee_info.param_types.len; + + try self.section.emitRaw(self.arena, .OpFunctionCall, 3 + total_params); + self.section.writeWord(operands.items[0]); // Copy result type-id + self.section.writeWord(operands.items[1]); // Copy result-id + self.section.writeOperand(ResultId, callee); + + // Add the new arguments + for (callee_info.invocation_globals.keys()) |global| { + const caller_global_index = caller_info.invocation_globals.getIndex(global).?; + const id = caller_new_info.invocationGlobalId(caller_global_index); + self.section.writeOperand(ResultId, id); + } + + // Add the original arguments + self.section.writeWords(operands.items[3..]); + }, + else => { + try self.section.emitRawInstruction(self.arena, inst.opcode, operands.items); + }, + } + } + } + + fn emitNewEntryPoints(self: *ModuleBuilder, info: ModuleInfo) !void { + var all_function_invocation_globals = std.AutoArrayHashMap(ResultId, void).init(self.arena); + + for (info.entry_points.keys(), 0..) |func, entry_point_index| { + const fn_info = info.functions.get(func).?; + const ep_id: ResultId = @enumFromInt(self.entry_point_new_id_base + @as(u32, @intCast(entry_point_index))); + const fn_type = self.function_types.get(.{ + .return_type = fn_info.return_type, + .param_types = fn_info.param_types, + }).?; + + try self.section.emit(self.arena, .OpFunction, .{ + .id_result_type = fn_info.return_type, + .id_result = ep_id, + .function_control = .{}, // TODO: Copy the attributes from the original function maybe? + .function_type = fn_type, + }); + + // Emit OpFunctionParameter instructions for the original kernel's parameters. + const params_id_base: u32 = @intFromEnum(self.allocIds(@intCast(fn_info.param_types.len))); + for (fn_info.param_types, 0..) |param_type, i| { + const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(i))); + try self.section.emit(self.arena, .OpFunctionParameter, .{ + .id_result_type = param_type, + .id_result = id, + }); + } + + try self.section.emit(self.arena, .OpLabel, .{ + .id_result = self.allocId(), + }); + + // Besides the IDs of the main kernel, we also need the + // dependencies of the globals. + // Just quickly construct that set here. + all_function_invocation_globals.clearRetainingCapacity(); + for (fn_info.invocation_globals.keys()) |global| { + try all_function_invocation_globals.put(global, {}); + const global_info = info.invocation_globals.get(global).?; + for (global_info.dependencies.keys()) |dependency| { + try all_function_invocation_globals.put(dependency, {}); + } + } + + // Declare the IDs of the invocation globals. + const global_id_base: u32 = @intFromEnum(self.allocIds(@intCast(all_function_invocation_globals.count()))); + for (all_function_invocation_globals.keys(), 0..) |global, i| { + const global_info = info.invocation_globals.get(global).?; + + const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(i))); + try self.section.emit(self.arena, .OpVariable, .{ + .id_result_type = global_info.ty, + .id_result = id, + .storage_class = .Function, + .initializer = null, + }); + } + + // Call initializers for invocation globals that need it + for (all_function_invocation_globals.keys()) |global| { + const global_info = info.invocation_globals.get(global).?; + if (global_info.initializer == .none) continue; + + const initializer_info = info.functions.get(global_info.initializer).?; + assert(initializer_info.param_types.len == 0); + + try self.callWithGlobalsAndLinearParams( + all_function_invocation_globals, + global_info.initializer, + initializer_info, + global_id_base, + undefined, + ); + } + + // Call the main kernel entry + try self.callWithGlobalsAndLinearParams( + all_function_invocation_globals, + func, + fn_info, + global_id_base, + params_id_base, + ); + + try self.section.emit(self.arena, .OpReturn, {}); + try self.section.emit(self.arena, .OpFunctionEnd, {}); + } + } + + fn callWithGlobalsAndLinearParams( + self: *ModuleBuilder, + all_globals: std.AutoArrayHashMap(ResultId, void), + func: ResultId, + callee_info: ModuleInfo.Fn, + global_id_base: u32, + params_id_base: u32, + ) !void { + const total_arguments = callee_info.invocation_globals.count() + callee_info.param_types.len; + try self.section.emitRaw(self.arena, .OpFunctionCall, 3 + total_arguments); + self.section.writeOperand(ResultId, callee_info.return_type); + self.section.writeOperand(ResultId, self.allocId()); + self.section.writeOperand(ResultId, func); + + // Add the invocation globals + for (callee_info.invocation_globals.keys()) |global| { + const index = all_globals.getIndex(global).?; + const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(index))); + self.section.writeOperand(ResultId, id); + } + + // Add the arguments + for (0..callee_info.param_types.len) |index| { + const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(index))); + self.section.writeOperand(ResultId, id); + } + } +}; + +pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { + var arena = std.heap.ArenaAllocator.init(parser.a); + defer arena.deinit(); + const a = arena.allocator(); + + var info = try ModuleInfo.parse(a, parser, binary.*); + try info.resolve(a); + + var builder = try ModuleBuilder.init(a, binary.*, info); + try builder.deriveNewFnInfo(info); + try builder.processPreamble(binary.*, info); + try builder.emitFunctionTypes(info); + try builder.rewriteFunctions(parser, binary.*, info); + try builder.emitNewEntryPoints(info); + try builder.finalize(parser.a, binary); +} diff --git a/src/link/SpirV/prune_unused.zig b/src/link/SpirV/prune_unused.zig new file mode 100644 index 000000000000..a6d0ceaea7cc --- /dev/null +++ b/src/link/SpirV/prune_unused.zig @@ -0,0 +1,354 @@ +//! This pass is used to simple pruning of unused things: +//! - Instructions at global scope +//! - Functions +//! Debug info and nonsemantic instructions are not handled; +//! this pass is mainly intended for cleaning up left over +//! stuff from codegen and other passes that is generated +//! but not actually used. + +const std = @import("std"); +const Allocator = std.mem.Allocator; +const assert = std.debug.assert; +const log = std.log.scoped(.spirv_link); + +const BinaryModule = @import("BinaryModule.zig"); +const Section = @import("../../codegen/spirv/Section.zig"); +const spec = @import("../../codegen/spirv/spec.zig"); +const Opcode = spec.Opcode; +const ResultId = spec.IdResult; +const Word = spec.Word; + +/// Return whether a particular opcode's instruction can be pruned. +/// These are idempotent instructions at globals scope and instructions +/// within functions that do not have any side effects. +/// The opcodes that return true here do not necessarily need to +/// have an .IdResult. If they don't, then they are regarded +/// as 'decoration'-style instructions that don't keep their +/// operands alive, but will be emitted if they are. +fn canPrune(op: Opcode) bool { + // This list should be as worked out as possible, but just + // getting common instructions is a good effort/effect ratio. + // When adding items to this list, also check whether the + // instruction requires any special control flow rules (like + // with labels and control flow and stuff) and whether the + // instruction has any non-trivial side effects (like OpLoad + // with the Volatile memory semantics). + return switch (op.class()) { + .TypeDeclaration, + .Conversion, + .Arithmetic, + .RelationalAndLogical, + .Bit, + => true, + else => switch (op) { + .OpFunction, + .OpUndef, + .OpString, + .OpName, + .OpMemberName, + // Prune OpConstant* instructions but + // retain OpSpecConstant declaration instructions + .OpConstantTrue, + .OpConstantFalse, + .OpConstant, + .OpConstantComposite, + .OpConstantSampler, + .OpConstantNull, + .OpSpecConstantOp, + // Prune ext inst import instructions, but not + // ext inst instructions themselves, because + // we don't know if they might have side effects. + .OpExtInstImport, + => true, + else => false, + }, + }; +} + +const ModuleInfo = struct { + const Fn = struct { + /// The index of the first callee in `callee_store`. + first_callee: usize, + }; + + /// Maps function result-id -> Fn information structure. + functions: std.AutoArrayHashMapUnmanaged(ResultId, Fn), + /// For each function, a list of function result-ids that it calls. + callee_store: []const ResultId, + /// For each instruction, the offset at which it appears in the source module. + result_id_to_code_offset: std.AutoArrayHashMapUnmanaged(ResultId, usize), + + /// Fetch the list of callees per function. Guaranteed to contain only unique IDs. + fn callees(self: ModuleInfo, fn_id: ResultId) []const ResultId { + const fn_index = self.functions.getIndex(fn_id).?; + const values = self.functions.values(); + const first_callee = values[fn_index].first_callee; + if (fn_index == values.len - 1) { + return self.callee_store[first_callee..]; + } else { + const next_first_callee = values[fn_index + 1].first_callee; + return self.callee_store[first_callee..next_first_callee]; + } + } + + /// Extract the information required to run this pass from the binary. + // TODO: Should the contents of this function be merged with that of lower_invocation_globals.zig? + // Many of the contents are the same... + fn parse( + arena: Allocator, + parser: *BinaryModule.Parser, + binary: BinaryModule, + ) !ModuleInfo { + var functions = std.AutoArrayHashMap(ResultId, Fn).init(arena); + var calls = std.AutoArrayHashMap(ResultId, void).init(arena); + var callee_store = std.ArrayList(ResultId).init(arena); + var result_id_to_code_offset = std.AutoArrayHashMap(ResultId, usize).init(arena); + var maybe_current_function: ?ResultId = null; + var it = binary.iterateInstructions(); + while (it.next()) |inst| { + const inst_spec = parser.getInstSpec(inst.opcode).?; + + // Result-id can only be the first or second operand + const maybe_result_id: ?ResultId = for (0..2) |i| { + if (inst_spec.operands.len > i and inst_spec.operands[i].kind == .IdResult) { + break @enumFromInt(inst.operands[i]); + } + } else null; + + // Only add result-ids of functions and anything outside a function. + // Result-ids declared inside functions cannot be reached outside anyway, + // and we don't care about the internals of functions anyway. + // Note that in the case of OpFunction, `maybe_current_function` is + // also `null`, because it is set below. + if (maybe_result_id) |result_id| { + try result_id_to_code_offset.put(result_id, inst.offset); + } + + switch (inst.opcode) { + .OpFunction => { + if (maybe_current_function) |current_function| { + log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function}); + return error.InvalidPhysicalFormat; + } + + maybe_current_function = @enumFromInt(inst.operands[1]); + }, + .OpFunctionCall => { + const callee: ResultId = @enumFromInt(inst.operands[2]); + try calls.put(callee, {}); + }, + .OpFunctionEnd => { + const current_function = maybe_current_function orelse { + log.err("encountered OpFunctionEnd without corresponding OpFunction", .{}); + return error.InvalidPhysicalFormat; + }; + const entry = try functions.getOrPut(current_function); + if (entry.found_existing) { + log.err("Function {} has duplicate definition", .{current_function}); + return error.DuplicateId; + } + + const first_callee = callee_store.items.len; + try callee_store.appendSlice(calls.keys()); + + entry.value_ptr.* = .{ + .first_callee = first_callee, + }; + maybe_current_function = null; + calls.clearRetainingCapacity(); + }, + else => {}, + } + } + + if (maybe_current_function) |current_function| { + log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function}); + return error.InvalidPhysicalFormat; + } + + return ModuleInfo{ + .functions = functions.unmanaged, + .callee_store = callee_store.items, + .result_id_to_code_offset = result_id_to_code_offset.unmanaged, + }; + } +}; + +const AliveMarker = struct { + parser: *BinaryModule.Parser, + binary: BinaryModule, + info: ModuleInfo, + result_id_offsets: std.ArrayList(u16), + alive: std.DynamicBitSetUnmanaged, + + fn markAlive(self: *AliveMarker, result_id: ResultId) BinaryModule.ParseError!void { + const index = self.info.result_id_to_code_offset.getIndex(result_id) orelse { + log.err("undefined result-id {}", .{result_id}); + return error.InvalidId; + }; + + if (self.alive.isSet(index)) { + return; + } + self.alive.set(index); + + const offset = self.info.result_id_to_code_offset.values()[index]; + const inst = self.binary.instructionAt(offset); + + if (inst.opcode == .OpFunction) { + try self.markFunctionAlive(inst); + } else { + try self.markInstructionAlive(inst); + } + } + + fn markFunctionAlive( + self: *AliveMarker, + func_inst: BinaryModule.Instruction, + ) !void { + // Go through the instruction and mark the + // operands of each instruction alive. + var it = self.binary.iterateInstructionsFrom(func_inst.offset); + try self.markInstructionAlive(it.next().?); + while (it.next()) |inst| { + if (inst.opcode == .OpFunctionEnd) { + break; + } + + if (!canPrune(inst.opcode)) { + try self.markInstructionAlive(inst); + } + } + } + + fn markInstructionAlive( + self: *AliveMarker, + inst: BinaryModule.Instruction, + ) !void { + const start_offset = self.result_id_offsets.items.len; + try self.parser.parseInstructionResultIds(self.binary, inst, &self.result_id_offsets); + const end_offset = self.result_id_offsets.items.len; + + // Recursive calls to markInstructionAlive() might change the pointer in self.result_id_offsets, + // so we need to iterate it manually. + var i = start_offset; + while (i < end_offset) : (i += 1) { + const offset = self.result_id_offsets.items[i]; + try self.markAlive(@enumFromInt(inst.operands[offset])); + } + } +}; + +fn removeIdsFromMap(a: Allocator, map: anytype, info: ModuleInfo, alive_marker: AliveMarker) !void { + var to_remove = std.ArrayList(ResultId).init(a); + var it = map.iterator(); + while (it.next()) |entry| { + const id = entry.key_ptr.*; + const index = info.result_id_to_code_offset.getIndex(id).?; + if (!alive_marker.alive.isSet(index)) { + try to_remove.append(id); + } + } + + for (to_remove.items) |id| { + assert(map.remove(id)); + } +} + +pub fn run(parser: *BinaryModule.Parser, binary: *BinaryModule) !void { + var arena = std.heap.ArenaAllocator.init(parser.a); + defer arena.deinit(); + const a = arena.allocator(); + + const info = try ModuleInfo.parse(a, parser, binary.*); + + var alive_marker = AliveMarker{ + .parser = parser, + .binary = binary.*, + .info = info, + .result_id_offsets = std.ArrayList(u16).init(a), + .alive = try std.DynamicBitSetUnmanaged.initEmpty(a, info.result_id_to_code_offset.count()), + }; + + // Mark initial stuff as slive + { + var it = binary.iterateInstructions(); + while (it.next()) |inst| { + if (inst.opcode == .OpFunction) { + // No need to process further. + break; + } else if (!canPrune(inst.opcode)) { + try alive_marker.markInstructionAlive(inst); + } + } + } + + var section = Section{}; + + var new_functions_section: ?usize = null; + var it = binary.iterateInstructions(); + skip: while (it.next()) |inst| { + const inst_spec = parser.getInstSpec(inst.opcode).?; + + reemit: { + if (!canPrune(inst.opcode)) { + break :reemit; + } + + // Result-id can only be the first or second operand + const result_id: ResultId = for (0..2) |i| { + if (inst_spec.operands.len > i and inst_spec.operands[i].kind == .IdResult) { + break @enumFromInt(inst.operands[i]); + } + } else { + // Instruction can be pruned but doesn't have a result id. + // Check all operands to see if they are alive, and emit it only if so. + alive_marker.result_id_offsets.items.len = 0; + try parser.parseInstructionResultIds(binary.*, inst, &alive_marker.result_id_offsets); + for (alive_marker.result_id_offsets.items) |offset| { + const id: ResultId = @enumFromInt(inst.operands[offset]); + const index = info.result_id_to_code_offset.getIndex(id).?; + + if (!alive_marker.alive.isSet(index)) { + continue :skip; + } + } + + break :reemit; + }; + + const index = info.result_id_to_code_offset.getIndex(result_id).?; + if (alive_marker.alive.isSet(index)) { + break :reemit; + } + + if (inst.opcode != .OpFunction) { + // Instruction can be pruned and its not alive, so skip it. + continue :skip; + } + + // We're at the start of a function that can be pruned, so skip everything until + // we encounter an OpFunctionEnd. + while (it.next()) |body_inst| { + if (body_inst.opcode == .OpFunctionEnd) + break; + } + + continue :skip; + } + + if (inst.opcode == .OpFunction and new_functions_section == null) { + new_functions_section = section.instructions.items.len; + } + + try section.emitRawInstruction(a, inst.opcode, inst.operands); + } + + // This pass might have pruned ext inst imports or arith types, update + // those maps to main consistency. + try removeIdsFromMap(a, &binary.ext_inst_map, info, alive_marker); + try removeIdsFromMap(a, &binary.arith_type_width, info, alive_marker); + + binary.instructions = try parser.a.dupe(Word, section.toWords()); + binary.sections.functions = new_functions_section orelse binary.instructions.len; +} diff --git a/test/behavior/align.zig b/test/behavior/align.zig index 671e46501a13..abf02941e08a 100644 --- a/test/behavior/align.zig +++ b/test/behavior/align.zig @@ -18,6 +18,7 @@ test "global variable alignment" { test "large alignment of local constant" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky const x: f32 align(128) = 12.34; try std.testing.expect(@intFromPtr(&x) % 128 == 0); diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig index 2a99218e0701..e76416ddb0fe 100644 --- a/test/behavior/basic.zig +++ b/test/behavior/basic.zig @@ -757,6 +757,7 @@ test "extern variable with non-pointer opaque type" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO @export(var_to_export, .{ .name = "opaque_extern_var" }); try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42); diff --git a/test/behavior/byval_arg_var.zig b/test/behavior/byval_arg_var.zig index 3a82ca86ad2e..01b5f90ef732 100644 --- a/test/behavior/byval_arg_var.zig +++ b/test/behavior/byval_arg_var.zig @@ -5,7 +5,6 @@ var result: []const u8 = "wrong"; test "pass string literal byvalue to a generic var param" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; start(); blowUpStack(10); diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig index e35f04696a3d..e88a53629eb9 100644 --- a/test/behavior/cast.zig +++ b/test/behavior/cast.zig @@ -1252,7 +1252,6 @@ test "implicit cast from *T to ?*anyopaque" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var a: u8 = 1; incrementVoidPtrValue(&a); @@ -2035,6 +2034,8 @@ test "peer type resolution: tuple pointer and optional slice" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO + // Miscompilation on Intel's OpenCL CPU runtime. + if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // flaky var a: ?[:0]const u8 = null; var b = &.{ @as(u8, 'x'), @as(u8, 'y'), @as(u8, 'z') }; diff --git a/test/behavior/error.zig b/test/behavior/error.zig index 4b8b69192e34..8e4dd2c091e0 100644 --- a/test/behavior/error.zig +++ b/test/behavior/error.zig @@ -124,7 +124,6 @@ test "debug info for optional error set" { test "implicit cast to optional to error union to return result loc" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn entry() !void { @@ -951,7 +950,6 @@ test "returning an error union containing a type with no runtime bits" { test "try used in recursive function with inferred error set" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO const Value = union(enum) { values: []const @This(), diff --git a/test/behavior/floatop.zig b/test/behavior/floatop.zig index e77737778664..02ee02e9fe82 100644 --- a/test/behavior/floatop.zig +++ b/test/behavior/floatop.zig @@ -127,7 +127,6 @@ test "cmp f16" { test "cmp f32/f64" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testCmp(f32); try comptime testCmp(f32); @@ -979,7 +978,6 @@ test "@abs f32/f64" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; try testFabs(f32); try comptime testFabs(f32); diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig index edf02d3e6ec8..e808710f9882 100644 --- a/test/behavior/optional.zig +++ b/test/behavior/optional.zig @@ -28,7 +28,6 @@ pub const EmptyStruct = struct {}; test "optional pointer to size zero struct" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var e = EmptyStruct{}; const o: ?*EmptyStruct = &e; @@ -36,8 +35,6 @@ test "optional pointer to size zero struct" { } test "equality compare optional pointers" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; - try testNullPtrsEql(); try comptime testNullPtrsEql(); } diff --git a/test/behavior/pointers.zig b/test/behavior/pointers.zig index f01c8d62f3b1..2539dd886d13 100644 --- a/test/behavior/pointers.zig +++ b/test/behavior/pointers.zig @@ -216,7 +216,6 @@ test "assign null directly to C pointer and test null equality" { if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; var x: [*c]i32 = null; _ = &x; diff --git a/test/behavior/vector.zig b/test/behavior/vector.zig index 97e80d84448a..4b2ab52c599e 100644 --- a/test/behavior/vector.zig +++ b/test/behavior/vector.zig @@ -372,7 +372,6 @@ test "load vector elements via comptime index" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { @@ -394,7 +393,6 @@ test "store vector elements via comptime index" { if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; const S = struct { fn doTheTest() !void { diff --git a/test/behavior/while.zig b/test/behavior/while.zig index 0c703d25d169..51ae8c5d9871 100644 --- a/test/behavior/while.zig +++ b/test/behavior/while.zig @@ -38,8 +38,6 @@ fn staticWhileLoop2() i32 { } test "while with continue expression" { - if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO - var sum: i32 = 0; { var i: i32 = 0; diff --git a/tools/gen_spirv_spec.zig b/tools/gen_spirv_spec.zig index 1f57ee426202..d94cdbdab5ae 100644 --- a/tools/gen_spirv_spec.zig +++ b/tools/gen_spirv_spec.zig @@ -1,45 +1,138 @@ const std = @import("std"); -const g = @import("spirv/grammar.zig"); const Allocator = std.mem.Allocator; +const g = @import("spirv/grammar.zig"); +const CoreRegistry = g.CoreRegistry; +const ExtensionRegistry = g.ExtensionRegistry; +const Instruction = g.Instruction; +const OperandKind = g.OperandKind; +const Enumerant = g.Enumerant; +const Operand = g.Operand; const ExtendedStructSet = std.StringHashMap(void); +const Extension = struct { + name: []const u8, + spec: ExtensionRegistry, +}; + +const CmpInst = struct { + fn lt(_: CmpInst, a: Instruction, b: Instruction) bool { + return a.opcode < b.opcode; + } +}; + +const StringPair = struct { []const u8, []const u8 }; + +const StringPairContext = struct { + pub fn hash(_: @This(), a: StringPair) u32 { + var hasher = std.hash.Wyhash.init(0); + const x, const y = a; + hasher.update(x); + hasher.update(y); + return @truncate(hasher.final()); + } + + pub fn eql(_: @This(), a: StringPair, b: StringPair, b_index: usize) bool { + _ = b_index; + const a_x, const a_y = a; + const b_x, const b_y = b; + return std.mem.eql(u8, a_x, b_x) and std.mem.eql(u8, a_y, b_y); + } +}; + +const OperandKindMap = std.ArrayHashMap(StringPair, OperandKind, StringPairContext, true); + +/// Khronos made it so that these names are not defined explicitly, so +/// we need to hardcode it (like they did). +/// See https://github.com/KhronosGroup/SPIRV-Registry/ +const set_names = std.ComptimeStringMap([]const u8, .{ + .{ "opencl.std.100", "OpenCL.std" }, + .{ "glsl.std.450", "GLSL.std.450" }, + .{ "opencl.debuginfo.100", "OpenCL.DebugInfo.100" }, + .{ "spv-amd-shader-ballot", "SPV_AMD_shader_ballot" }, + .{ "nonsemantic.shader.debuginfo.100", "NonSemantic.Shader.DebugInfo.100" }, + .{ "nonsemantic.vkspreflection", "NonSemantic.VkspReflection" }, + .{ "nonsemantic.clspvreflection", "NonSemantic.ClspvReflection.6" }, // This version needs to be handled manually + .{ "spv-amd-gcn-shader", "SPV_AMD_gcn_shader" }, + .{ "spv-amd-shader-trinary-minmax", "SPV_AMD_shader_trinary_minmax" }, + .{ "debuginfo", "DebugInfo" }, + .{ "nonsemantic.debugprintf", "NonSemantic.DebugPrintf" }, + .{ "spv-amd-shader-explicit-vertex-parameter", "SPV_AMD_shader_explicit_vertex_parameter" }, + .{ "nonsemantic.debugbreak", "NonSemantic.DebugBreak" }, + .{ "zig", "zig" }, +}); + pub fn main() !void { var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); defer arena.deinit(); - const allocator = arena.allocator(); + const a = arena.allocator(); + + const args = try std.process.argsAlloc(a); + if (args.len != 3) { + usageAndExit(args[0], 1); + } + + const json_path = try std.fs.path.join(a, &.{ args[1], "include/spirv/unified1/" }); + const dir = try std.fs.cwd().openDir(json_path, .{ .iterate = true }); + + const core_spec = try readRegistry(CoreRegistry, a, dir, "spirv.core.grammar.json"); + std.sort.block(Instruction, core_spec.instructions, CmpInst{}, CmpInst.lt); + + var exts = std.ArrayList(Extension).init(a); + + var it = dir.iterate(); + while (try it.next()) |entry| { + if (entry.kind != .file) { + continue; + } + + try readExtRegistry(&exts, a, dir, entry.name); + } + + try readExtRegistry(&exts, a, std.fs.cwd(), args[2]); + + var bw = std.io.bufferedWriter(std.io.getStdOut().writer()); + try render(bw.writer(), a, core_spec, exts.items); + try bw.flush(); +} - const args = try std.process.argsAlloc(allocator); - if (args.len != 2) { - usageAndExit(std.io.getStdErr(), args[0], 1); +fn readExtRegistry(exts: *std.ArrayList(Extension), a: Allocator, dir: std.fs.Dir, sub_path: []const u8) !void { + const filename = std.fs.path.basename(sub_path); + if (!std.mem.startsWith(u8, filename, "extinst.")) { + return; } - const spec_path = args[1]; - const spec = try std.fs.cwd().readFileAlloc(allocator, spec_path, std.math.maxInt(usize)); + std.debug.assert(std.mem.endsWith(u8, filename, ".grammar.json")); + const name = filename["extinst.".len .. filename.len - ".grammar.json".len]; + const spec = try readRegistry(ExtensionRegistry, a, dir, sub_path); + std.sort.block(Instruction, spec.instructions, CmpInst{}, CmpInst.lt); + + try exts.append(.{ .name = set_names.get(name).?, .spec = spec }); +} + +fn readRegistry(comptime RegistryType: type, a: Allocator, dir: std.fs.Dir, path: []const u8) !RegistryType { + const spec = try dir.readFileAlloc(a, path, std.math.maxInt(usize)); // Required for json parsing. @setEvalBranchQuota(10000); - var scanner = std.json.Scanner.initCompleteInput(allocator, spec); + var scanner = std.json.Scanner.initCompleteInput(a, spec); var diagnostics = std.json.Diagnostics{}; scanner.enableDiagnostics(&diagnostics); - const parsed = std.json.parseFromTokenSource(g.CoreRegistry, allocator, &scanner, .{}) catch |err| { - std.debug.print("line,col: {},{}\n", .{ diagnostics.getLine(), diagnostics.getColumn() }); + const parsed = std.json.parseFromTokenSource(RegistryType, a, &scanner, .{}) catch |err| { + std.debug.print("{s}:{}:{}:\n", .{ path, diagnostics.getLine(), diagnostics.getColumn() }); return err; }; - - var bw = std.io.bufferedWriter(std.io.getStdOut().writer()); - try render(bw.writer(), allocator, parsed.value); - try bw.flush(); + return parsed.value; } /// Returns a set with types that require an extra struct for the `Instruction` interface /// to the spir-v spec, or whether the original type can be used. fn extendedStructs( - arena: Allocator, - kinds: []const g.OperandKind, + a: Allocator, + kinds: []const OperandKind, ) !ExtendedStructSet { - var map = ExtendedStructSet.init(arena); + var map = ExtendedStructSet.init(a); try map.ensureTotalCapacity(@as(u32, @intCast(kinds.len))); for (kinds) |kind| { @@ -73,10 +166,12 @@ fn tagPriorityScore(tag: []const u8) usize { } } -fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void { +fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []const Extension) !void { try writer.writeAll( \\//! This file is auto-generated by tools/gen_spirv_spec.zig. \\ + \\const std = @import("std"); + \\ \\pub const Version = packed struct(Word) { \\ padding: u8 = 0, \\ minor: u8, @@ -89,8 +184,21 @@ fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void \\}; \\ \\pub const Word = u32; - \\pub const IdResult = struct{ - \\ id: Word, + \\pub const IdResult = enum(Word) { + \\ none, + \\ _, + \\ + \\ pub fn format( + \\ self: IdResult, + \\ comptime _: []const u8, + \\ _: std.fmt.FormatOptions, + \\ writer: anytype, + \\ ) @TypeOf(writer).Error!void { + \\ switch (self) { + \\ .none => try writer.writeAll("(none)"), + \\ else => try writer.print("%{}", .{@intFromEnum(self)}), + \\ } + \\ } \\}; \\pub const IdResultType = IdResult; \\pub const IdRef = IdResult; @@ -99,6 +207,7 @@ fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void \\pub const IdScope = IdRef; \\ \\pub const LiteralInteger = Word; + \\pub const LiteralFloat = Word; \\pub const LiteralString = []const u8; \\pub const LiteralContextDependentNumber = union(enum) { \\ int32: i32, @@ -139,6 +248,13 @@ fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void \\ parameters: []const OperandKind, \\}; \\ + \\pub const Instruction = struct { + \\ name: []const u8, + \\ opcode: Word, + \\ operands: []const Operand, + \\}; + \\ + \\pub const zig_generator_id: Word = 41; \\ ); @@ -151,15 +267,123 @@ fn render(writer: anytype, allocator: Allocator, registry: g.CoreRegistry) !void .{ registry.major_version, registry.minor_version, registry.revision, registry.magic_number }, ); - const extended_structs = try extendedStructs(allocator, registry.operand_kinds); - try renderClass(writer, allocator, registry.instructions); - try renderOperandKind(writer, registry.operand_kinds); - try renderOpcodes(writer, allocator, registry.instructions, extended_structs); - try renderOperandKinds(writer, allocator, registry.operand_kinds, extended_structs); + // Merge the operand kinds from all extensions together. + // var all_operand_kinds = std.ArrayList(OperandKind).init(a); + // try all_operand_kinds.appendSlice(registry.operand_kinds); + var all_operand_kinds = OperandKindMap.init(a); + for (registry.operand_kinds) |kind| { + try all_operand_kinds.putNoClobber(.{ "core", kind.kind }, kind); + } + for (extensions) |ext| { + // Note: extensions may define the same operand kind, with different + // parameters. Instead of trying to merge them, just discriminate them + // using the name of the extension. This is similar to what + // the official headers do. + + try all_operand_kinds.ensureUnusedCapacity(ext.spec.operand_kinds.len); + for (ext.spec.operand_kinds) |kind| { + var new_kind = kind; + new_kind.kind = try std.mem.join(a, ".", &.{ ext.name, kind.kind }); + try all_operand_kinds.putNoClobber(.{ ext.name, kind.kind }, new_kind); + } + } + + const extended_structs = try extendedStructs(a, all_operand_kinds.values()); + // Note: extensions don't seem to have class. + try renderClass(writer, a, registry.instructions); + try renderOperandKind(writer, all_operand_kinds.values()); + try renderOpcodes(writer, a, registry.instructions, extended_structs); + try renderOperandKinds(writer, a, all_operand_kinds.values(), extended_structs); + try renderInstructionSet(writer, a, registry, extensions, all_operand_kinds); +} + +fn renderInstructionSet( + writer: anytype, + a: Allocator, + core: CoreRegistry, + extensions: []const Extension, + all_operand_kinds: OperandKindMap, +) !void { + _ = a; + try writer.writeAll( + \\pub const InstructionSet = enum { + \\ core, + ); + + for (extensions) |ext| { + try writer.print("{},\n", .{std.zig.fmtId(ext.name)}); + } + + try writer.writeAll( + \\ + \\ pub fn instructions(self: InstructionSet) []const Instruction { + \\ return switch (self) { + \\ + ); + + try renderInstructionsCase(writer, "core", core.instructions, all_operand_kinds); + for (extensions) |ext| { + try renderInstructionsCase(writer, ext.name, ext.spec.instructions, all_operand_kinds); + } + + try writer.writeAll( + \\ }; + \\ } + \\}; + \\ + ); +} + +fn renderInstructionsCase( + writer: anytype, + set_name: []const u8, + instructions: []const Instruction, + all_operand_kinds: OperandKindMap, +) !void { + // Note: theoretically we could dedup from tags and give every instruction a list of aliases, + // but there aren't so many total aliases and that would add more overhead in total. We will + // just filter those out when needed. + + try writer.print(".{} => &[_]Instruction{{\n", .{std.zig.fmtId(set_name)}); + + for (instructions) |inst| { + try writer.print( + \\.{{ + \\ .name = "{s}", + \\ .opcode = {}, + \\ .operands = &[_]Operand{{ + \\ + , .{ inst.opname, inst.opcode }); + + for (inst.operands) |operand| { + const quantifier = if (operand.quantifier) |q| + switch (q) { + .@"?" => "optional", + .@"*" => "variadic", + } + else + "required"; + + const kind = all_operand_kinds.get(.{ set_name, operand.kind }) orelse + all_operand_kinds.get(.{ "core", operand.kind }).?; + try writer.print(".{{.kind = .{}, .quantifier = .{s}}},\n", .{ std.zig.fmtId(kind.kind), quantifier }); + } + + try writer.writeAll( + \\ }, + \\}, + \\ + ); + } + + try writer.writeAll( + \\}, + \\ + ); } -fn renderClass(writer: anytype, allocator: Allocator, instructions: []const g.Instruction) !void { - var class_map = std.StringArrayHashMap(void).init(allocator); +fn renderClass(writer: anytype, a: Allocator, instructions: []const Instruction) !void { + var class_map = std.StringArrayHashMap(void).init(a); for (instructions) |inst| { if (std.mem.eql(u8, inst.class.?, "@exclude")) { @@ -173,7 +397,7 @@ fn renderClass(writer: anytype, allocator: Allocator, instructions: []const g.In try renderInstructionClass(writer, class); try writer.writeAll(",\n"); } - try writer.writeAll("};\n"); + try writer.writeAll("};\n\n"); } fn renderInstructionClass(writer: anytype, class: []const u8) !void { @@ -192,15 +416,20 @@ fn renderInstructionClass(writer: anytype, class: []const u8) !void { } } -fn renderOperandKind(writer: anytype, operands: []const g.OperandKind) !void { - try writer.writeAll("pub const OperandKind = enum {\n"); +fn renderOperandKind(writer: anytype, operands: []const OperandKind) !void { + try writer.writeAll( + \\pub const OperandKind = enum { + \\ Opcode, + \\ + ); for (operands) |operand| { try writer.print("{},\n", .{std.zig.fmtId(operand.kind)}); } try writer.writeAll( \\ \\pub fn category(self: OperandKind) OperandCategory { - \\return switch (self) { + \\ return switch (self) { + \\ .Opcode => .literal, \\ ); for (operands) |operand| { @@ -214,10 +443,11 @@ fn renderOperandKind(writer: anytype, operands: []const g.OperandKind) !void { try writer.print(".{} => .{s},\n", .{ std.zig.fmtId(operand.kind), cat }); } try writer.writeAll( - \\}; + \\ }; \\} \\pub fn enumerants(self: OperandKind) []const Enumerant { - \\return switch (self) { + \\ return switch (self) { + \\ .Opcode => unreachable, \\ ); for (operands) |operand| { @@ -242,7 +472,7 @@ fn renderOperandKind(writer: anytype, operands: []const g.OperandKind) !void { try writer.writeAll("};\n}\n};\n"); } -fn renderEnumerant(writer: anytype, enumerant: g.Enumerant) !void { +fn renderEnumerant(writer: anytype, enumerant: Enumerant) !void { try writer.print(".{{.name = \"{s}\", .value = ", .{enumerant.enumerant}); switch (enumerant.value) { .bitflag => |flag| try writer.writeAll(flag), @@ -260,14 +490,14 @@ fn renderEnumerant(writer: anytype, enumerant: g.Enumerant) !void { fn renderOpcodes( writer: anytype, - allocator: Allocator, - instructions: []const g.Instruction, + a: Allocator, + instructions: []const Instruction, extended_structs: ExtendedStructSet, ) !void { - var inst_map = std.AutoArrayHashMap(u32, usize).init(allocator); + var inst_map = std.AutoArrayHashMap(u32, usize).init(a); try inst_map.ensureTotalCapacity(instructions.len); - var aliases = std.ArrayList(struct { inst: usize, alias: usize }).init(allocator); + var aliases = std.ArrayList(struct { inst: usize, alias: usize }).init(a); try aliases.ensureTotalCapacity(instructions.len); for (instructions, 0..) |inst, i| { @@ -302,7 +532,9 @@ fn renderOpcodes( try writer.print("{} = {},\n", .{ std.zig.fmtId(inst.opname), inst.opcode }); } - try writer.writeByte('\n'); + try writer.writeAll( + \\ + ); for (aliases.items) |alias| { try writer.print("pub const {} = Opcode.{};\n", .{ @@ -314,7 +546,7 @@ fn renderOpcodes( try writer.writeAll( \\ \\pub fn Operands(comptime self: Opcode) type { - \\return switch (self) { + \\ return switch (self) { \\ ); @@ -324,35 +556,10 @@ fn renderOpcodes( } try writer.writeAll( - \\}; - \\} - \\pub fn operands(self: Opcode) []const Operand { - \\return switch (self) { - \\ - ); - - for (instructions_indices) |i| { - const inst = instructions[i]; - try writer.print(".{} => &[_]Operand{{", .{std.zig.fmtId(inst.opname)}); - for (inst.operands) |operand| { - const quantifier = if (operand.quantifier) |q| - switch (q) { - .@"?" => "optional", - .@"*" => "variadic", - } - else - "required"; - - try writer.print(".{{.kind = .{s}, .quantifier = .{s}}},", .{ operand.kind, quantifier }); - } - try writer.writeAll("},\n"); - } - - try writer.writeAll( - \\}; + \\ }; \\} \\pub fn class(self: Opcode) Class { - \\return switch (self) { + \\ return switch (self) { \\ ); @@ -363,19 +570,24 @@ fn renderOpcodes( try writer.writeAll(",\n"); } - try writer.writeAll("};\n}\n};\n"); + try writer.writeAll( + \\ }; + \\} + \\}; + \\ + ); } fn renderOperandKinds( writer: anytype, - allocator: Allocator, - kinds: []const g.OperandKind, + a: Allocator, + kinds: []const OperandKind, extended_structs: ExtendedStructSet, ) !void { for (kinds) |kind| { switch (kind.category) { - .ValueEnum => try renderValueEnum(writer, allocator, kind, extended_structs), - .BitEnum => try renderBitEnum(writer, allocator, kind, extended_structs), + .ValueEnum => try renderValueEnum(writer, a, kind, extended_structs), + .BitEnum => try renderBitEnum(writer, a, kind, extended_structs), else => {}, } } @@ -383,20 +595,26 @@ fn renderOperandKinds( fn renderValueEnum( writer: anytype, - allocator: Allocator, - enumeration: g.OperandKind, + a: Allocator, + enumeration: OperandKind, extended_structs: ExtendedStructSet, ) !void { const enumerants = enumeration.enumerants orelse return error.InvalidRegistry; - var enum_map = std.AutoArrayHashMap(u32, usize).init(allocator); + var enum_map = std.AutoArrayHashMap(u32, usize).init(a); try enum_map.ensureTotalCapacity(enumerants.len); - var aliases = std.ArrayList(struct { enumerant: usize, alias: usize }).init(allocator); + var aliases = std.ArrayList(struct { enumerant: usize, alias: usize }).init(a); try aliases.ensureTotalCapacity(enumerants.len); for (enumerants, 0..) |enumerant, i| { - const result = enum_map.getOrPutAssumeCapacity(enumerant.value.int); + try writer.context.flush(); + const value: u31 = switch (enumerant.value) { + .int => |value| value, + // Some extensions declare ints as string + .bitflag => |value| try std.fmt.parseInt(u31, value, 10), + }; + const result = enum_map.getOrPutAssumeCapacity(value); if (!result.found_existing) { result.value_ptr.* = i; continue; @@ -422,9 +640,12 @@ fn renderValueEnum( for (enum_indices) |i| { const enumerant = enumerants[i]; - if (enumerant.value != .int) return error.InvalidRegistry; + // if (enumerant.value != .int) return error.InvalidRegistry; - try writer.print("{} = {},\n", .{ std.zig.fmtId(enumerant.enumerant), enumerant.value.int }); + switch (enumerant.value) { + .int => |value| try writer.print("{} = {},\n", .{ std.zig.fmtId(enumerant.enumerant), value }), + .bitflag => |value| try writer.print("{} = {s},\n", .{ std.zig.fmtId(enumerant.enumerant), value }), + } } try writer.writeByte('\n'); @@ -454,8 +675,8 @@ fn renderValueEnum( fn renderBitEnum( writer: anytype, - allocator: Allocator, - enumeration: g.OperandKind, + a: Allocator, + enumeration: OperandKind, extended_structs: ExtendedStructSet, ) !void { try writer.print("pub const {s} = packed struct {{\n", .{std.zig.fmtId(enumeration.kind)}); @@ -463,7 +684,7 @@ fn renderBitEnum( var flags_by_bitpos = [_]?usize{null} ** 32; const enumerants = enumeration.enumerants orelse return error.InvalidRegistry; - var aliases = std.ArrayList(struct { flag: usize, alias: u5 }).init(allocator); + var aliases = std.ArrayList(struct { flag: usize, alias: u5 }).init(a); try aliases.ensureTotalCapacity(enumerants.len); for (enumerants, 0..) |enumerant, i| { @@ -471,6 +692,10 @@ fn renderBitEnum( const value = try parseHexInt(enumerant.value.bitflag); if (value == 0) { continue; // Skip 'none' items + } else if (std.mem.eql(u8, enumerant.enumerant, "FlagIsPublic")) { + // This flag is special and poorly defined in the json files. + // Just skip it for now + continue; } std.debug.assert(@popCount(value) == 1); @@ -540,7 +765,7 @@ fn renderOperand( mask, }, field_name: []const u8, - parameters: []const g.Operand, + parameters: []const Operand, extended_structs: ExtendedStructSet, ) !void { if (kind == .instruction) { @@ -606,7 +831,7 @@ fn renderOperand( try writer.writeAll(",\n"); } -fn renderFieldName(writer: anytype, operands: []const g.Operand, field_index: usize) !void { +fn renderFieldName(writer: anytype, operands: []const Operand, field_index: usize) !void { const operand = operands[field_index]; // Should be enough for all names - adjust as needed. @@ -673,16 +898,16 @@ fn parseHexInt(text: []const u8) !u31 { return try std.fmt.parseInt(u31, text[prefix.len..], 16); } -fn usageAndExit(file: std.fs.File, arg0: []const u8, code: u8) noreturn { - file.writer().print( - \\Usage: {s} +fn usageAndExit(arg0: []const u8, code: u8) noreturn { + std.io.getStdErr().writer().print( + \\Usage: {s} \\ - \\Generates Zig bindings for a SPIR-V specification .json (either core or - \\extinst versions). The result, printed to stdout, should be used to update + \\Generates Zig bindings for SPIR-V specifications found in the SPIRV-Headers + \\repository. The result, printed to stdout, should be used to update \\files in src/codegen/spirv. Don't forget to format the output. \\ - \\The relevant specifications can be obtained from the SPIR-V registry: - \\https://github.com/KhronosGroup/SPIRV-Headers/blob/master/include/spirv/unified1/ + \\ should point to a clone of + \\https://github.com/KhronosGroup/SPIRV-Headers/ \\ , .{arg0}) catch std.process.exit(1); std.process.exit(code); diff --git a/tools/spirv/grammar.zig b/tools/spirv/grammar.zig index 446ed0a06233..c077d6e7e471 100644 --- a/tools/spirv/grammar.zig +++ b/tools/spirv/grammar.zig @@ -22,8 +22,8 @@ pub const CoreRegistry = struct { }; pub const ExtensionRegistry = struct { - copyright: [][]const u8, - version: u32, + copyright: ?[][]const u8 = null, + version: ?u32 = null, revision: u32, instructions: []Instruction, operand_kinds: []OperandKind = &[_]OperandKind{}, @@ -40,6 +40,8 @@ pub const Instruction = struct { opcode: u32, operands: []Operand = &[_]Operand{}, capabilities: [][]const u8 = &[_][]const u8{}, + // DebugModuleINTEL has this... + capability: ?[]const u8 = null, extensions: [][]const u8 = &[_][]const u8{}, version: ?[]const u8 = null,