srctree

pub const zig_call_abi_ver = 3;

 

assert(decl.has_tv); // TODO: Do we need to handle a situation where this is false?

const kind: SpvModule.Decl.Kind = if (decl.val.isFuncBody(mod))

else switch (decl.@"addrspace") {

.generic => .invocation_global,

else => .global,

};

fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index) !IdRef {

 

const mod = self.module;

const ty = Type.fromInterned(mod.intern_pool.typeOf(val));

const decl_ptr_ty_ref = try self.ptrType(ty, .Generic);

 

const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, .Function });

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(.invocation_global);

try self.addFunctionDep(spv_decl_index, .Function);

// constant lowering of this value will need to be deferred to an initializer similar to

// other globals.

const result_id = self.spv.declPtr(spv_decl_index).result_id;

{

// 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;

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 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 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.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 try self.castToGeneric(self.typeId(decl_ptr_ty_ref), result_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, .{});

var types: [2]Type = undefined;

types = .{ err_ty, payload_ty };

types = .{ payload_ty, err_ty };

return try self.constructStruct(ty, &types, &constituents);

return self.constructStruct(

ty,

&.{ ptr_ty, Type.usize },

&.{ ptr_id, len_id },

);

return try self.constructStruct(

ty,

&.{ payload_ty, Type.bool },

&.{ payload_id, has_pl_id },

);

return self.constructArray(ty, constituents);

inline .vector_type => return self.constructVector(ty, constituents),

var types = std.ArrayList(Type).init(self.gpa);

defer types.deinit();

 

try types.append(field_ty);

return try self.constructStruct(ty, types.items, constituents.items);

// 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);

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,

};

 

comptime assert(zig_call_abi_ver == 3);

switch (fn_info.cc) {

.Unspecified, .Kernel, .Fragment, .Vertex, .C => {},

else => unreachable, // TODO

}

 

return try wip.dg.constructArray(wip.result_ty, wip.results);

/// %p_invocation_globals_struct_ty = ...

/// %K = OpTypeFunction %void %p_invocation_globals_struct_ty %p_anyerror

/// %p_invocation_globals = OpFunctionParameter p_invocation_globals_struct_ty

/// %result = OpFunctionCall %anyerror %func %p_invocation_globals

const kernel_proto_ty_ref = try self.spv.resolve(.{

.function_type = .{

.return_type = void_ty_ref,

.parameters = &.{ptr_anyerror_ty_ref},

},

});

const result_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));

const prototype_ty_ref = try self.resolveType(decl.ty, .direct);

.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),

 

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);

}

 

// TODO: This could probably be done in a better way...

 

// The root block of a function declaration should appear before OpVariable instructions,

// so it is generated into the function's prologue.

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);

},

}

// Append the actual code into the functions section.

const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module));

try self.spv.debugName(result_id, fqn);

 

// 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 final_storage_class = self.spvStorageClass(decl.@"addrspace");

assert(final_storage_class != .Generic); // These should be instance globals

 

const ptr_ty_ref = try self.ptrType(decl.ty, 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 fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module));

try self.spv.debugName(result_id, fqn);

},

.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;

};

 

try self.spv.declareDeclDeps(spv_decl_index, &.{});

 

const ptr_ty_ref = try self.ptrType(decl.ty, .Function);

 

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 = &.{},

} });

 

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 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);

 

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 = &.{},

});

}

},

.opencl => try self.spv.importInstructionSet(.@"OpenCL.std"),

.vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"),

.opencl => try self.spv.importInstructionSet(.@"OpenCL.std"),

.vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"),

return try self.constructStruct(

&.{ operand_ty, ov_ty },

return try self.constructStruct(

&.{ operand_ty, ov_ty },

return try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id);

// 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

.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;

},

return try self.constructStruct(

slice_ty,

&.{ elem_ptr_ty, Type.usize },

&.{ elem_ptr_id, len_id },

);

const ptr_ty = self.typeOf(bin_op.lhs);

return try self.constructStruct(

slice_ty,

&.{ ptr_ty, Type.usize },

&.{ ptr_id, len_id },

);

const types = try self.gpa.alloc(Type, elements.len);

defer self.gpa.free(types);

types[index] = Type.fromInterned(field_ty);

types[index] = field_ty;

return try self.constructStruct(

result_ty,

types[0..index],

constituents[0..index],

);

return try self.constructVector(result_ty, elem_ids);

return try self.constructArray(result_ty, elem_ids);

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);

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);

const types = [_]Type{ payload_ty, Type.bool };

return try self.constructStruct(optional_ty, &types, &members);

const label: IdRef = @enumFromInt(@intFromEnum(first_case_label) + case_i);

1 => .{ .uint32 = @intCast(int_val) },

const label: IdResult = @enumFromInt(@intFromEnum(first_case_label) + case_i);

comptime assert(zig_call_abi_ver == 3);

/// 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) = .{},

 

self.instruction_map.deinit(self.gpa);

// 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);

}

}

 

const index = self.instruction_map.getIndex(opcode_text) orelse {

const inst = spec.InstructionSet.core.instructions()[index];

self.inst.opcode = @enumFromInt(inst.opcode);

 

const expected_operands = inst.operands;

const SimpleType = enum {

void,

bool,

};

/// Ref to a .fwd_ptr_type.

// - ArrayStride

// - MaxByteOffset

// 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.

/// 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.

extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, IdRef) = .{},

return @enumFromInt(self.next_result_id);

return @enumFromInt(self.next_result_id);

if (decl.kind == .global) {

try interface.append(decl.result_id);

pub fn finalize(self: *Module, a: Allocator, target: std.Target) ![]Word {

// TODO: Audit calls to allocId() in this function to make it idempotent.

spec.zig_generator_id,

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;

pub fn importInstructionSet(self: *Module, set: spec.InstructionSet) !IdRef {

assert(set != .core);

 

.name = @tagName(set),

pub fn allocDecl(self: *Module, kind: Decl.Kind) !Decl.Index {

.kind = kind,

return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1))));

/// 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.

/// 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);

}

 

spec.IdResult => section.writeWord(@intFromEnum(operand)),

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]) }),

.id_result_type = @enumFromInt(0),

.id_result = @enumFromInt(1),

.file = @enumFromInt(256),

.merge_block = @enumFromInt(10),

.continue_target = @enumFromInt(20),

.entry_point = @enumFromInt(888),

{

"version": 0,

"revision": 0,

"instructions": [

{

"opname": "InvocationGlobal",

"opcode": 0,

"operands": [

{ "kind": "IdRef", "name": "initializer function" }

]

}

]

}

const std = @import("std");

 

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 LiteralFloat = Word;

pub const Instruction = struct {

name: []const u8,

opcode: Word,

operands: []const Operand,

};

 

pub const zig_generator_id: Word = 41;

 

Opcode,

RawAccessChainOperands,

HostAccessQualifier,

CooperativeMatrixOperands,

CooperativeMatrixLayout,

CooperativeMatrixUse,

InitializationModeQualifier,

LoadCacheControl,

StoreCacheControl,

NamedMaximumNumberOfRegisters,

LiteralFloat,

@"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",

.Opcode => .literal,

.RawAccessChainOperands => .bit_enum,

.HostAccessQualifier => .value_enum,

.CooperativeMatrixOperands => .bit_enum,

.CooperativeMatrixLayout => .value_enum,

.CooperativeMatrixUse => .value_enum,

.InitializationModeQualifier => .value_enum,

.LoadCacheControl => .value_enum,

.StoreCacheControl => .value_enum,

.NamedMaximumNumberOfRegisters => .value_enum,

.LiteralFloat => .literal,

.@"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,

.Opcode => unreachable,

.{ .name = "AllowContract", .value = 0x10000, .parameters = &[_]OperandKind{} },

.{ .name = "AllowReassoc", .value = 0x20000, .parameters = &[_]OperandKind{} },

.{ .name = "AllowTransform", .value = 0x40000, .parameters = &[_]OperandKind{} },

.{ .name = "NoFusionINTEL", .value = 0x800000, .parameters = &[_]OperandKind{} },

.{ .name = "LoopCountINTEL", .value = 0x1000000, .parameters = &[_]OperandKind{.LiteralInteger} },

.{ .name = "MaxReinvocationDelayINTEL", .value = 0x2000000, .parameters = &[_]OperandKind{.LiteralInteger} },

.{ .name = "AliasScopeINTELMask", .value = 0x10000, .parameters = &[_]OperandKind{.IdRef} },

.{ .name = "NoAliasINTELMask", .value = 0x20000, .parameters = &[_]OperandKind{.IdRef} },

.{ .name = "ForceOpacityMicromap2StateEXT", .value = 0x0400, .parameters = &[_]OperandKind{} },

.RawAccessChainOperands => &[_]Enumerant{

.{ .name = "RobustnessPerComponentNV", .value = 0x0001, .parameters = &[_]OperandKind{} },

.{ .name = "RobustnessPerElementNV", .value = 0x0002, .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{} },

.{ .name = "TaskEXT", .value = 5364, .parameters = &[_]OperandKind{} },

.{ .name = "MeshEXT", .value = 5365, .parameters = &[_]OperandKind{} },

.{ .name = "NonCoherentColorAttachmentReadEXT", .value = 4169, .parameters = &[_]OperandKind{} },

.{ .name = "NonCoherentDepthAttachmentReadEXT", .value = 4170, .parameters = &[_]OperandKind{} },

.{ .name = "NonCoherentStencilAttachmentReadEXT", .value = 4171, .parameters = &[_]OperandKind{} },

.{ .name = "EarlyAndLateFragmentTestsAMD", .value = 5017, .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 = "OutputLinesEXT", .value = 5269, .parameters = &[_]OperandKind{} },

.{ .name = "OutputPrimitivesEXT", .value = 5270, .parameters = &[_]OperandKind{.LiteralInteger} },

.{ .name = "OutputTrianglesEXT", .value = 5298, .parameters = &[_]OperandKind{} },

.{ .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} },

.{ .name = "TileImageEXT", .value = 4172, .parameters = &[_]OperandKind{} },

.{ .name = "NodePayloadAMDX", .value = 5068, .parameters = &[_]OperandKind{} },

.{ .name = "NodeOutputPayloadAMDX", .value = 5076, .parameters = &[_]OperandKind{} },

.{ .name = "HitObjectAttributeNV", .value = 5385, .parameters = &[_]OperandKind{} },

.{ .name = "TaskPayloadWorkgroupEXT", .value = 5402, .parameters = &[_]OperandKind{} },

.{ .name = "TileImageDataEXT", .value = 4173, .parameters = &[_]OperandKind{} },

.{ .name = "UnsignedIntRaw10EXT", .value = 19, .parameters = &[_]OperandKind{} },

.{ .name = "UnsignedIntRaw12EXT", .value = 20, .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{} },

},

.{ .name = "RuntimeAlignedINTEL", .value = 5940, .parameters = &[_]OperandKind{} },

.{ .name = "WeightTextureQCOM", .value = 4487, .parameters = &[_]OperandKind{} },

.{ .name = "BlockMatchTextureQCOM", .value = 4488, .parameters = &[_]OperandKind{} },

.{ .name = "BlockMatchSamplerQCOM", .value = 4499, .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 = "PerPrimitiveEXT", .value = 5271, .parameters = &[_]OperandKind{} },

.{ .name = "HitObjectShaderRecordBufferNV", .value = 5386, .parameters = &[_]OperandKind{} },

.{ .name = "StridesizeINTEL", .value = 5883, .parameters = &[_]OperandKind{.LiteralInteger} },

.{ .name = "WordsizeINTEL", .value = 5884, .parameters = &[_]OperandKind{.LiteralInteger} },

.{ .name = "TrueDualPortINTEL", .value = 5885, .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 = "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 } },

.{ .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 = "CoalescedInputCountAMDX", .value = 5021, .parameters = &[_]OperandKind{} },

.{ .name = "ShaderIndexAMDX", .value = 5073, .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 = "HitTriangleVertexPositionsKHR", .value = 5335, .parameters = &[_]OperandKind{} },

.{ .name = "HitMicroTriangleVertexPositionsNV", .value = 5337, .parameters = &[_]OperandKind{} },

.{ .name = "HitMicroTriangleVertexBarycentricsNV", .value = 5344, .parameters = &[_]OperandKind{} },

.{ .name = "HitKindFrontFacingMicroTriangleNV", .value = 5405, .parameters = &[_]OperandKind{} },

.{ .name = "HitKindBackFacingMicroTriangleNV", .value = 5406, .parameters = &[_]OperandKind{} },

.{ .name = "CullMaskKHR", .value = 6021, .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 = "TextureSampleWeightedQCOM", .value = 4484, .parameters = &[_]OperandKind{} },

.{ .name = "TextureBoxFilterQCOM", .value = 4485, .parameters = &[_]OperandKind{} },

.{ .name = "TextureBlockMatchQCOM", .value = 4486, .parameters = &[_]OperandKind{} },

.{ .name = "TextureBlockMatch2QCOM", .value = 4498, .parameters = &[_]OperandKind{} },

.{ .name = "ShaderEnqueueAMDX", .value = 5067, .parameters = &[_]OperandKind{} },

.{ .name = "QuadControlKHR", .value = 5087, .parameters = &[_]OperandKind{} },

.{ .name = "MeshShadingEXT", .value = 5283, .parameters = &[_]OperandKind{} },

.{ .name = "RayTracingPositionFetchKHR", .value = 5336, .parameters = &[_]OperandKind{} },

.{ .name = "DisplacementMicromapNV", .value = 5380, .parameters = &[_]OperandKind{} },

.{ .name = "RayTracingOpacityMicromapEXT", .value = 5381, .parameters = &[_]OperandKind{} },

.{ .name = "ShaderInvocationReorderNV", .value = 5383, .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 = "FPGADSPControlINTEL", .value = 5908, .parameters = &[_]OperandKind{} },

.{ .name = "MemoryAccessAliasingINTEL", .value = 5910, .parameters = &[_]OperandKind{} },

.{ .name = "FPGAInvocationPipeliningAttributesINTEL", .value = 5916, .parameters = &[_]OperandKind{} },

.{ .name = "RuntimeAlignedAttributeINTEL", .value = 5939, .parameters = &[_]OperandKind{} },

.{ .name = "RayCullMaskKHR", .value = 6020, .parameters = &[_]OperandKind{} },

.{ .name = "CooperativeMatrixKHR", .value = 6022, .parameters = &[_]OperandKind{} },

.{ .name = "GroupNonUniformRotateKHR", .value = 6026, .parameters = &[_]OperandKind{} },

.{ .name = "FloatControls2", .value = 6029, .parameters = &[_]OperandKind{} },

.{ .name = "LongCompositesINTEL", .value = 6089, .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{} },

.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{} },

},

.LiteralFloat => 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} },

},

OpColorAttachmentReadEXT = 4160,

OpDepthAttachmentReadEXT = 4161,

OpStencilAttachmentReadEXT = 4162,

OpGroupNonUniformRotateKHR = 4431,

OpTypeCooperativeMatrixKHR = 4456,

OpCooperativeMatrixLoadKHR = 4457,

OpCooperativeMatrixStoreKHR = 4458,

OpCooperativeMatrixMulAddKHR = 4459,

OpCooperativeMatrixLengthKHR = 4460,

OpImageSampleWeightedQCOM = 4480,

OpImageBoxFilterQCOM = 4481,

OpImageBlockMatchSSDQCOM = 4482,

OpImageBlockMatchSADQCOM = 4483,

OpImageBlockMatchWindowSSDQCOM = 4500,

OpImageBlockMatchWindowSADQCOM = 4501,

OpImageBlockMatchGatherSSDQCOM = 4502,

OpImageBlockMatchGatherSADQCOM = 4503,

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,

OpEmitMeshTasksEXT = 5294,

OpSetMeshOutputsEXT = 5295,

OpFetchMicroTriangleVertexPositionNV = 5300,

OpFetchMicroTriangleVertexBarycentricNV = 5301,

OpRayQueryGetIntersectionTriangleVertexPositionsKHR = 5340,

OpRawAccessChainNV = 5398,

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,

.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 },

.OpGroupNonUniformRotateKHR => struct { id_result_type: IdResultType, id_result: IdResult, execution: IdScope, value: IdRef, delta: IdRef, clustersize: ?IdRef = 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 },

.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 },

.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 },

.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 },

.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 },

.OpRayQueryGetIntersectionTriangleVertexPositionsKHR => struct { id_result_type: IdResultType, id_result: IdResult, rayquery: IdRef, intersection: IdRef },

.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 },

.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 },

.OpColorAttachmentReadEXT => .Image,

.OpDepthAttachmentReadEXT => .Image,

.OpStencilAttachmentReadEXT => .Image,

.OpGroupNonUniformRotateKHR => .Group,

.OpTypeCooperativeMatrixKHR => .TypeDeclaration,

.OpCooperativeMatrixLoadKHR => .Memory,

.OpCooperativeMatrixStoreKHR => .Memory,

.OpCooperativeMatrixMulAddKHR => .Arithmetic,

.OpCooperativeMatrixLengthKHR => .Miscellaneous,

.OpTypeRayQueryKHR => .TypeDeclaration,

.OpImageSampleWeightedQCOM => .Image,

.OpImageBoxFilterQCOM => .Image,

.OpImageBlockMatchSSDQCOM => .Image,

.OpImageBlockMatchSADQCOM => .Image,

.OpImageBlockMatchWindowSSDQCOM => .Image,

.OpImageBlockMatchWindowSADQCOM => .Image,

.OpImageBlockMatchGatherSSDQCOM => .Image,

.OpImageBlockMatchGatherSADQCOM => .Image,

.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,

.OpEmitMeshTasksEXT => .Reserved,

.OpSetMeshOutputsEXT => .Reserved,

.OpFetchMicroTriangleVertexPositionNV => .Reserved,

.OpFetchMicroTriangleVertexBarycentricNV => .Reserved,

.OpRayQueryGetIntersectionTriangleVertexPositionsKHR => .Reserved,

.OpTypeAccelerationStructureKHR => .TypeDeclaration,

.OpTypeCooperativeMatrixNV => .TypeDeclaration,

.OpRawAccessChainNV => .Memory,

.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,

AllowContract: bool = false,

AllowReassoc: bool = false,

AllowTransform: bool = false,

 

pub const AllowContractFastINTEL: FPFastMathMode = .{ .AllowContract = true };

pub const AllowReassocINTEL: FPFastMathMode = .{ .AllowReassoc = true };

LoopCountINTEL: bool = false,

MaxReinvocationDelayINTEL: bool = false,

NoFusionINTEL: bool = false,

LoopCountINTEL: ?struct { literal_integer: LiteralInteger } = null,

MaxReinvocationDelayINTEL: ?struct { literal_integer: LiteralInteger } = null,

AliasScopeINTELMask: bool = false,

NoAliasINTELMask: bool = false,

AliasScopeINTELMask: ?struct { id_ref: IdRef } = null,

NoAliasINTELMask: ?struct { id_ref: IdRef } = null,

ForceOpacityMicromap2StateEXT: 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,

};

SYCL = 7,

HERO_C = 8,

NZSL = 9,

WGSL = 10,

Slang = 11,

Zig = 12,

TaskEXT = 5364,

MeshEXT = 5365,

NonCoherentColorAttachmentReadEXT = 4169,

NonCoherentDepthAttachmentReadEXT = 4170,

NonCoherentStencilAttachmentReadEXT = 4171,

EarlyAndLateFragmentTestsAMD = 5017,

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,

OutputTrianglesEXT = 5298,

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;

NonCoherentColorAttachmentReadEXT,

NonCoherentDepthAttachmentReadEXT,

NonCoherentStencilAttachmentReadEXT,

EarlyAndLateFragmentTestsAMD,

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 },

OutputTrianglesEXT,

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 },

TileImageEXT = 4172,

NodePayloadAMDX = 5068,

NodeOutputPayloadAMDX = 5076,

HitObjectAttributeNV = 5385,

TaskPayloadWorkgroupEXT = 5402,

TileImageDataEXT = 4173,

UnsignedIntRaw10EXT = 19,

UnsignedIntRaw12EXT = 20,

pub const HostAccessQualifier = enum(u32) {

NoneINTEL = 0,

ReadINTEL = 1,

WriteINTEL = 2,

ReadWriteINTEL = 3,

};

RuntimeAlignedINTEL = 5940,

WeightTextureQCOM = 4487,

BlockMatchTextureQCOM = 4488,

BlockMatchSamplerQCOM = 4499,

NodeSharesPayloadLimitsWithAMDX = 5019,

NodeMaxPayloadsAMDX = 5020,

TrackFinishWritingAMDX = 5078,

PayloadNodeNameAMDX = 5091,

PerPrimitiveEXT = 5271,

HitObjectShaderRecordBufferNV = 5386,

StridesizeINTEL = 5883,

WordsizeINTEL = 5884,

TrueDualPortINTEL = 5885,

MathOpDSPModeINTEL = 5909,

AliasScopeINTEL = 5914,

NoAliasINTEL = 5915,

InitiationIntervalINTEL = 5917,

MaxConcurrencyINTEL = 5918,

PipelineEnableINTEL = 5919,

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;

WeightTextureQCOM,

BlockMatchTextureQCOM,

BlockMatchSamplerQCOM,

NodeSharesPayloadLimitsWithAMDX: struct { payload_array: IdRef },

NodeMaxPayloadsAMDX: struct { max_number_of_payloads: IdRef },

TrackFinishWritingAMDX,

PayloadNodeNameAMDX: struct { node_name: LiteralString },

PerPrimitiveEXT,

HitObjectShaderRecordBufferNV,

StridesizeINTEL: struct { stride_size: LiteralInteger },

WordsizeINTEL: struct { word_size: LiteralInteger },

TrueDualPortINTEL,

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 },

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 },

CoreIDARM = 4160,

CoreCountARM = 4161,

CoreMaxIDARM = 4162,

WarpIDARM = 4163,

WarpMaxIDARM = 4164,

CoalescedInputCountAMDX = 5021,

ShaderIndexAMDX = 5073,

PrimitivePointIndicesEXT = 5294,

PrimitiveLineIndicesEXT = 5295,

PrimitiveTriangleIndicesEXT = 5296,

CullPrimitiveEXT = 5299,

HitTriangleVertexPositionsKHR = 5335,

HitMicroTriangleVertexPositionsNV = 5337,

HitMicroTriangleVertexBarycentricsNV = 5344,

HitKindFrontFacingMicroTriangleNV = 5405,

HitKindBackFacingMicroTriangleNV = 5406,

CullMaskKHR = 6021,

CoreBuiltinsARM = 4165,

TileImageColorReadAccessEXT = 4166,

TileImageDepthReadAccessEXT = 4167,

TileImageStencilReadAccessEXT = 4168,

TextureSampleWeightedQCOM = 4484,

TextureBoxFilterQCOM = 4485,

TextureBlockMatchQCOM = 4486,

TextureBlockMatch2QCOM = 4498,

ShaderEnqueueAMDX = 5067,

QuadControlKHR = 5087,

MeshShadingEXT = 5283,

RayTracingPositionFetchKHR = 5336,

DisplacementMicromapNV = 5380,

RayTracingOpacityMicromapEXT = 5381,

ShaderInvocationReorderNV = 5383,

RayQueryPositionFetchKHR = 5391,

AtomicFloat16VectorNV = 5404,

RayTracingDisplacementMicromapNV = 5409,

RawAccessChainsNV = 5414,

FPGADSPControlINTEL = 5908,

MemoryAccessAliasingINTEL = 5910,

FPGAInvocationPipeliningAttributesINTEL = 5916,

RuntimeAlignedAttributeINTEL = 5939,

RayCullMaskKHR = 6020,

CooperativeMatrixKHR = 6022,

GroupNonUniformRotateKHR = 6026,

FloatControls2 = 6029,

LongCompositesINTEL = 6089,

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 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 },