spirv: make generic globals invocation-local

This commit is contained in:
Robin Voetter 2024-03-02 13:08:21 +01:00
parent 20d7bb68ac
commit 9b18125562
No known key found for this signature in database
10 changed files with 1262 additions and 778 deletions

View File

@ -30,6 +30,8 @@ const SpvAssembler = @import("spirv/Assembler.zig");
const InstMap = std.AutoHashMapUnmanaged(Air.Inst.Index, IdRef); const InstMap = std.AutoHashMapUnmanaged(Air.Inst.Index, IdRef);
pub const zig_call_abi_ver = 3;
/// We want to store some extra facts about types as mapped from Zig to SPIR-V. /// We want to store some extra facts about types as mapped from Zig to SPIR-V.
/// This structure is used to keep that extra information, as well as /// This structure is used to keep that extra information, as well as
/// the cached reference to the type. /// the cached reference to the type.
@ -252,15 +254,18 @@ pub const Object = struct {
/// Note: Function does not actually generate the decl, it just allocates an index. /// Note: Function does not actually generate the decl, it just allocates an index.
pub fn resolveDecl(self: *Object, mod: *Module, decl_index: InternPool.DeclIndex) !SpvModule.Decl.Index { pub fn resolveDecl(self: *Object, mod: *Module, decl_index: InternPool.DeclIndex) !SpvModule.Decl.Index {
const decl = mod.declPtr(decl_index); const decl = mod.declPtr(decl_index);
assert(decl.has_tv); // TODO: Do we need to handle a situation where this is false?
try mod.markDeclAlive(decl); try mod.markDeclAlive(decl);
const entry = try self.decl_link.getOrPut(self.gpa, decl_index); const entry = try self.decl_link.getOrPut(self.gpa, decl_index);
if (!entry.found_existing) { if (!entry.found_existing) {
// TODO: Extern fn? // TODO: Extern fn?
const kind: SpvModule.DeclKind = if (decl.val.isFuncBody(mod)) const kind: SpvModule.Decl.Kind = if (decl.val.isFuncBody(mod))
.func .func
else else switch (decl.@"addrspace") {
.global; .generic => .invocation_global,
else => .global,
};
entry.value_ptr.* = try self.spv.allocDecl(kind); entry.value_ptr.* = try self.spv.allocDecl(kind);
} }
@ -443,87 +448,90 @@ const DeclGen = struct {
return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage. return self.inst_results.get(index).?; // Assertion means instruction does not dominate usage.
} }
fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index, storage_class: StorageClass) !IdRef { fn resolveAnonDecl(self: *DeclGen, val: InternPool.Index) !IdRef {
// TODO: This cannot be a function at this point, but it should probably be handled anyway. // TODO: This cannot be a function at this point, but it should probably be handled anyway.
const mod = self.module;
const ty = Type.fromInterned(mod.intern_pool.typeOf(val));
const decl_ptr_ty_ref = try self.ptrType(ty, .Generic);
const spv_decl_index = blk: { const spv_decl_index = blk: {
const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, storage_class }); const entry = try self.object.anon_decl_link.getOrPut(self.object.gpa, .{ val, .Function });
if (entry.found_existing) { if (entry.found_existing) {
try self.addFunctionDep(entry.value_ptr.*, storage_class); try self.addFunctionDep(entry.value_ptr.*, .Function);
return self.spv.declPtr(entry.value_ptr.*).result_id;
const result_id = self.spv.declPtr(entry.value_ptr.*).result_id;
return try self.castToGeneric(self.typeId(decl_ptr_ty_ref), result_id);
} }
const spv_decl_index = try self.spv.allocDecl(.global); const spv_decl_index = try self.spv.allocDecl(.invocation_global);
try self.addFunctionDep(spv_decl_index, storage_class); try self.addFunctionDep(spv_decl_index, .Function);
entry.value_ptr.* = spv_decl_index; entry.value_ptr.* = spv_decl_index;
break :blk spv_decl_index; break :blk spv_decl_index;
}; };
const mod = self.module;
const ty = Type.fromInterned(mod.intern_pool.typeOf(val));
const ptr_ty_ref = try self.ptrType(ty, storage_class);
const var_id = self.spv.declPtr(spv_decl_index).result_id;
const section = &self.spv.sections.types_globals_constants;
try section.emit(self.spv.gpa, .OpVariable, .{
.id_result_type = self.typeId(ptr_ty_ref),
.id_result = var_id,
.storage_class = storage_class,
});
// TODO: At some point we will be able to generate this all constant here, but then all of // TODO: At some point we will be able to generate this all constant here, but then all of
// constant() will need to be implemented such that it doesn't generate any at-runtime code. // constant() will need to be implemented such that it doesn't generate any at-runtime code.
// NOTE: Because this is a global, we really only want to initialize it once. Therefore the // NOTE: Because this is a global, we really only want to initialize it once. Therefore the
// constant lowering of this value will need to be deferred to some other function, which // constant lowering of this value will need to be deferred to an initializer similar to
// is then added to the list of initializers using endGlobal(). // other globals.
// Save the current state so that we can temporarily generate into a different function. const result_id = self.spv.declPtr(spv_decl_index).result_id;
// 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); // Save the current state so that we can temporarily generate into a different function.
// TODO: This should probably be made a little more robust.
const func = self.func;
defer self.func = func;
const block_label = self.current_block_label;
defer self.current_block_label = block_label;
// TODO: Merge this with genDecl? self.func = .{};
const begin = self.spv.beginGlobal(); defer self.func.deinit(self.gpa);
const void_ty_ref = try self.resolveType(Type.void, .direct); const void_ty_ref = try self.resolveType(Type.void, .direct);
const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
.return_type = void_ty_ref, .return_type = void_ty_ref,
.parameters = &.{}, .parameters = &.{},
} }); } });
const initializer_id = self.spv.allocId(); 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.prologue.emit(self.spv.gpa, .OpFunction, .{
try self.func.body.emit(self.spv.gpa, .OpStore, .{ .id_result_type = self.typeId(void_ty_ref),
.pointer = var_id, .id_result = initializer_id,
.object = val_id, .function_control = .{},
}); .function_type = self.typeId(initializer_proto_ty_ref),
});
const root_block_id = self.spv.allocId();
try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{
.id_result = root_block_id,
});
self.current_block_label = root_block_id;
self.spv.endGlobal(spv_decl_index, begin, var_id, initializer_id); const val_id = try self.constant(ty, Value.fromInterned(val), .indirect);
try self.func.body.emit(self.spv.gpa, .OpReturn, {}); try self.func.body.emit(self.spv.gpa, .OpStore, .{
try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); .pointer = result_id,
try self.spv.addFunction(spv_decl_index, self.func); .object = val_id,
});
try self.spv.debugNameFmt(var_id, "__anon_{d}", .{@intFromEnum(val)}); try self.func.body.emit(self.spv.gpa, .OpReturn, {});
try self.spv.debugNameFmt(initializer_id, "initializer of __anon_{d}", .{@intFromEnum(val)}); try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});
try self.spv.addFunction(spv_decl_index, self.func);
return var_id; 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);
} }
fn addFunctionDep(self: *DeclGen, decl_index: SpvModule.Decl.Index, storage_class: StorageClass) !void { fn addFunctionDep(self: *DeclGen, decl_index: SpvModule.Decl.Index, storage_class: StorageClass) !void {
@ -1179,19 +1187,10 @@ const DeclGen = struct {
unreachable; // TODO unreachable; // TODO
} }
const final_storage_class = self.spvStorageClass(ty.ptrAddressSpace(mod)); // Anon decl refs are always generic.
const actual_storage_class = switch (final_storage_class) { assert(ty.ptrAddressSpace(mod) == .generic);
.Generic => .CrossWorkgroup, const decl_ptr_ty_ref = try self.ptrType(decl_ty, .Generic);
else => |other| other, const ptr_id = try self.resolveAnonDecl(decl_val);
};
const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);
const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class);
const ptr_id = switch (final_storage_class) {
.Generic => try self.castToGeneric(self.typeId(decl_ptr_ty_ref), decl_id),
else => decl_id,
};
if (decl_ptr_ty_ref != ty_ref) { if (decl_ptr_ty_ref != ty_ref) {
// Differing pointer types, insert a cast. // Differing pointer types, insert a cast.
@ -1229,8 +1228,13 @@ const DeclGen = struct {
} }
const spv_decl_index = try self.object.resolveDecl(mod, decl_index); const spv_decl_index = try self.object.resolveDecl(mod, decl_index);
const spv_decl = self.spv.declPtr(spv_decl_index);
const decl_id = switch (spv_decl.kind) {
.func => unreachable, // TODO: Is this possible?
.global, .invocation_global => spv_decl.result_id,
};
const decl_id = self.spv.declPtr(spv_decl_index).result_id;
const final_storage_class = self.spvStorageClass(decl.@"addrspace"); const final_storage_class = self.spvStorageClass(decl.@"addrspace");
try self.addFunctionDep(spv_decl_index, final_storage_class); try self.addFunctionDep(spv_decl_index, final_storage_class);
@ -1509,6 +1513,13 @@ const DeclGen = struct {
if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref; if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
const fn_info = mod.typeToFunc(ty).?; const fn_info = mod.typeToFunc(ty).?;
comptime assert(zig_call_abi_ver == 3);
switch (fn_info.cc) {
.Unspecified, .Kernel, .Fragment, .Vertex, .C => {},
else => unreachable, // TODO
}
// TODO: Put this somewhere in Sema.zig // TODO: Put this somewhere in Sema.zig
if (fn_info.is_var_args) if (fn_info.is_var_args)
return self.fail("VarArgs functions are unsupported for SPIR-V", .{}); return self.fail("VarArgs functions are unsupported for SPIR-V", .{});
@ -1956,13 +1967,15 @@ const DeclGen = struct {
/// (anyerror!void has the same layout as anyerror). /// (anyerror!void has the same layout as anyerror).
/// Each test declaration generates a function like. /// Each test declaration generates a function like.
/// %anyerror = OpTypeInt 0 16 /// %anyerror = OpTypeInt 0 16
/// %p_invocation_globals_struct_ty = ...
/// %p_anyerror = OpTypePointer CrossWorkgroup %anyerror /// %p_anyerror = OpTypePointer CrossWorkgroup %anyerror
/// %K = OpTypeFunction %void %p_anyerror /// %K = OpTypeFunction %void %p_invocation_globals_struct_ty %p_anyerror
/// ///
/// %test = OpFunction %void %K /// %test = OpFunction %void %K
/// %p_invocation_globals = OpFunctionParameter p_invocation_globals_struct_ty
/// %p_err = OpFunctionParameter %p_anyerror /// %p_err = OpFunctionParameter %p_anyerror
/// %lbl = OpLabel /// %lbl = OpLabel
/// %result = OpFunctionCall %anyerror %func /// %result = OpFunctionCall %anyerror %func %p_invocation_globals
/// OpStore %p_err %result /// OpStore %p_err %result
/// OpFunctionEnd /// OpFunctionEnd
/// TODO is to also write out the error as a function call parameter, and to somehow fetch /// TODO is to also write out the error as a function call parameter, and to somehow fetch
@ -1972,10 +1985,12 @@ const DeclGen = struct {
const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup); const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup);
const void_ty_ref = try self.resolveType(Type.void, .direct); const void_ty_ref = try self.resolveType(Type.void, .direct);
const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{ const kernel_proto_ty_ref = try self.spv.resolve(.{
.return_type = void_ty_ref, .function_type = .{
.parameters = &.{ptr_anyerror_ty_ref}, .return_type = void_ty_ref,
} }); .parameters = &.{ptr_anyerror_ty_ref},
},
});
const test_id = self.spv.declPtr(spv_test_decl_index).result_id; const test_id = self.spv.declPtr(spv_test_decl_index).result_id;
@ -2026,147 +2041,164 @@ const DeclGen = struct {
const ip = &mod.intern_pool; const ip = &mod.intern_pool;
const decl = mod.declPtr(self.decl_index); const decl = mod.declPtr(self.decl_index);
const spv_decl_index = try self.object.resolveDecl(mod, self.decl_index); const spv_decl_index = try self.object.resolveDecl(mod, self.decl_index);
const target = self.getTarget(); const result_id = self.spv.declPtr(spv_decl_index).result_id;
const decl_id = self.spv.declPtr(spv_decl_index).result_id; switch (self.spv.declPtr(spv_decl_index).kind) {
.func => {
assert(decl.ty.zigTypeTag(mod) == .Fn);
const fn_info = mod.typeToFunc(decl.ty).?;
const return_ty_ref = try self.resolveFnReturnType(Type.fromInterned(fn_info.return_type));
if (decl.val.getFunction(mod)) |_| { const prototype_ty_ref = try self.resolveType(decl.ty, .direct);
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_id = try self.resolveTypeId(decl.ty);
try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{
.id_result_type = self.typeId(return_ty_ref),
.id_result = decl_id,
.function_control = switch (fn_info.cc) {
.Inline => .{ .Inline = true },
else => .{},
},
.function_type = prototype_id,
});
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...
const root_block_id = self.spv.allocId();
// The root block of a function declaration should appear before OpVariable instructions,
// so it is generated into the function's prologue.
try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{
.id_result = root_block_id,
});
self.current_block_label = root_block_id;
const main_body = self.air.getMainBody();
switch (self.control_flow) {
.structured => {
_ = try self.genStructuredBody(.selection, main_body);
// We always expect paths to here to end, but we still need the block
// to act as a dummy merge block.
try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
},
.unstructured => {
try self.genBody(main_body);
},
}
try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});
// Append the actual code into the functions section.
try self.spv.addFunction(spv_decl_index, self.func);
const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module));
try self.spv.debugName(decl_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);
}
} else {
const opt_init_val: ?Value = blk: {
if (decl.val.getVariable(mod)) |payload| {
if (payload.is_extern) break :blk null;
break :blk Value.fromInterned(payload.init);
}
break :blk decl.val;
};
// Generate the actual variable for the global...
const final_storage_class = self.spvStorageClass(decl.@"addrspace");
const actual_storage_class = blk: {
if (target.os.tag != .vulkan) {
break :blk switch (final_storage_class) {
.Generic => .CrossWorkgroup,
else => final_storage_class,
};
}
break :blk final_storage_class;
};
const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class);
const begin = self.spv.beginGlobal();
try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{
.id_result_type = self.typeId(ptr_ty_ref),
.id_result = decl_id,
.storage_class = actual_storage_class,
});
const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module));
try self.spv.debugName(decl_id, fqn);
if (opt_init_val) |init_val| {
// Currently, initializers for CrossWorkgroup variables is not implemented
// in Mesa. Therefore we generate an initialization kernel instead.
const void_ty_ref = try self.resolveType(Type.void, .direct);
const initializer_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
.return_type = void_ty_ref,
.parameters = &.{},
} });
// Now emit the instructions that initialize the variable.
const initializer_id = self.spv.allocId();
try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{ try self.func.prologue.emit(self.spv.gpa, .OpFunction, .{
.id_result_type = self.typeId(void_ty_ref), .id_result_type = self.typeId(return_ty_ref),
.id_result = initializer_id, .id_result = result_id,
.function_control = .{}, .function_control = switch (fn_info.cc) {
.function_type = self.typeId(initializer_proto_ty_ref), .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...
const root_block_id = self.spv.allocId(); const root_block_id = self.spv.allocId();
// The root block of a function declaration should appear before OpVariable instructions,
// so it is generated into the function's prologue.
try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{ try self.func.prologue.emit(self.spv.gpa, .OpLabel, .{
.id_result = root_block_id, .id_result = root_block_id,
}); });
self.current_block_label = root_block_id; self.current_block_label = root_block_id;
const val_id = try self.constant(decl.ty, init_val, .indirect); const main_body = self.air.getMainBody();
try self.func.body.emit(self.spv.gpa, .OpStore, .{ switch (self.control_flow) {
.pointer = decl_id, .structured => {
.object = val_id, _ = 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.
// TODO: We should be able to get rid of this by now... try self.func.body.emit(self.spv.gpa, .OpUnreachable, {});
self.spv.endGlobal(spv_decl_index, begin, decl_id, initializer_id); },
.unstructured => {
try self.func.body.emit(self.spv.gpa, .OpReturn, {}); try self.genBody(main_body);
},
}
try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {}); try self.func.body.emit(self.spv.gpa, .OpFunctionEnd, {});
// Append the actual code into the functions section.
try self.spv.addFunction(spv_decl_index, self.func); try self.spv.addFunction(spv_decl_index, self.func);
try self.spv.debugNameFmt(initializer_id, "initializer of {s}", .{fqn}); const fqn = ip.stringToSlice(try decl.fullyQualifiedName(self.module));
} else { try self.spv.debugName(result_id, fqn);
self.spv.endGlobal(spv_decl_index, begin, decl_id, null);
// 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);
try self.spv.declareDeclDeps(spv_decl_index, &.{}); try self.spv.declareDeclDeps(spv_decl_index, &.{});
} },
.invocation_global => {
const maybe_init_val: ?Value = blk: {
if (decl.val.getVariable(mod)) |payload| {
if (payload.is_extern) break :blk null;
break :blk Value.fromInterned(payload.init);
}
break :blk decl.val;
};
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 = &.{},
});
}
},
} }
} }
@ -2559,8 +2591,8 @@ const DeclGen = struct {
else => unreachable, else => unreachable,
}; };
const set_id = switch (target.os.tag) { const set_id = switch (target.os.tag) {
.opencl => try self.spv.importInstructionSet(.opencl), .opencl => try self.spv.importInstructionSet(.@"OpenCL.std"),
.vulkan => try self.spv.importInstructionSet(.glsl), .vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"),
else => unreachable, else => unreachable,
}; };
@ -2734,8 +2766,8 @@ const DeclGen = struct {
else => unreachable, else => unreachable,
}; };
const set_id = switch (target.os.tag) { const set_id = switch (target.os.tag) {
.opencl => try self.spv.importInstructionSet(.opencl), .opencl => try self.spv.importInstructionSet(.@"OpenCL.std"),
.vulkan => try self.spv.importInstructionSet(.glsl), .vulkan => try self.spv.importInstructionSet(.@"GLSL.std.450"),
else => unreachable, else => unreachable,
}; };
@ -5427,9 +5459,9 @@ const DeclGen = struct {
const result_id = self.spv.allocId(); const result_id = self.spv.allocId();
const callee_id = try self.resolve(pl_op.operand); const callee_id = try self.resolve(pl_op.operand);
comptime assert(zig_call_abi_ver == 3);
const params = try self.gpa.alloc(spec.IdRef, args.len); const params = try self.gpa.alloc(spec.IdRef, args.len);
defer self.gpa.free(params); defer self.gpa.free(params);
var n_params: usize = 0; var n_params: usize = 0;
for (args) |arg| { for (args) |arg| {
// Note: resolve() might emit instructions, so we need to call it // Note: resolve() might emit instructions, so we need to call it

View File

@ -134,7 +134,10 @@ const Tag = enum {
/// data is (bool) type /// data is (bool) type
bool_false, bool_false,
const SimpleType = enum { void, bool }; const SimpleType = enum {
void,
bool,
};
const VectorType = Key.VectorType; const VectorType = Key.VectorType;
const ArrayType = Key.ArrayType; const ArrayType = Key.ArrayType;
@ -287,11 +290,12 @@ pub const Key = union(enum) {
pub const PointerType = struct { pub const PointerType = struct {
storage_class: StorageClass, storage_class: StorageClass,
child_type: Ref, child_type: Ref,
/// Ref to a .fwd_ptr_type.
fwd: Ref, fwd: Ref,
// TODO: Decorations: // TODO: Decorations:
// - Alignment // - Alignment
// - ArrayStride, // - ArrayStride
// - MaxByteOffset, // - MaxByteOffset
}; };
pub const ForwardPointerType = struct { pub const ForwardPointerType = struct {
@ -728,6 +732,9 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
// }, // },
.ptr_type => |ptr| Item{ .ptr_type => |ptr| Item{
.tag = .type_ptr_simple, .tag = .type_ptr_simple,
// For this variant we need to steal the ID of the forward-declaration, instead
// of allocating one manually. This will make sure that we get a single result-id
// any possibly forward declared pointer type.
.result_id = self.resultId(ptr.fwd), .result_id = self.resultId(ptr.fwd),
.data = try self.addExtra(spv, Tag.SimplePointerType{ .data = try self.addExtra(spv, Tag.SimplePointerType{
.storage_class = ptr.storage_class, .storage_class = ptr.storage_class,
@ -896,24 +903,6 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
}, },
}; };
}, },
// .type_ptr_generic => .{
// .ptr_type = .{
// .storage_class = .Generic,
// .child_type = @enumFromInt(data),
// },
// },
// .type_ptr_crosswgp => .{
// .ptr_type = .{
// .storage_class = .CrossWorkgroup,
// .child_type = @enumFromInt(data),
// },
// },
// .type_ptr_function => .{
// .ptr_type = .{
// .storage_class = .Function,
// .child_type = @enumFromInt(data),
// },
// },
.type_ptr_simple => { .type_ptr_simple => {
const payload = self.extraData(Tag.SimplePointerType, data); const payload = self.extraData(Tag.SimplePointerType, data);
return .{ return .{

View File

@ -72,9 +72,20 @@ pub const Decl = struct {
/// Index to refer to a Decl by. /// Index to refer to a Decl by.
pub const Index = enum(u32) { _ }; pub const Index = enum(u32) { _ };
/// The result-id to be used for this declaration. This is the final result-id /// Useful to tell what kind of decl this is, and hold the result-id or field index
/// of the decl, which may be an OpFunction, OpVariable, or the result of a sequence /// to be used for this decl.
/// of OpSpecConstantOp operations. pub const Kind = enum {
func,
global,
invocation_global,
};
/// See comment on Kind
kind: Kind,
/// The result-id associated to this decl. The specific meaning of this depends on `kind`:
/// - For `func`, this is the result-id of the associated OpFunction instruction.
/// - For `global`, this is the result-id of the associated OpVariable instruction.
/// - For `invocation_global`, this is the result-id of the associated InvocationGlobal instruction.
result_id: IdRef, result_id: IdRef,
/// The offset of the first dependency of this decl in the `decl_deps` array. /// The offset of the first dependency of this decl in the `decl_deps` array.
begin_dep: u32, begin_dep: u32,
@ -82,20 +93,6 @@ pub const Decl = struct {
end_dep: u32, end_dep: u32,
}; };
/// Globals must be kept in order: operations involving globals must be ordered
/// so that the global declaration precedes any usage.
pub const Global = struct {
/// This is the result-id of the OpVariable instruction that declares the global.
result_id: IdRef,
/// The offset into `self.globals.section` of the first instruction of this global
/// declaration.
begin_inst: u32,
/// The past-end offset into `self.flobals.section`.
end_inst: u32,
/// The result-id of the function that initializes this value.
initializer_id: ?IdRef,
};
/// This models a kernel entry point. /// This models a kernel entry point.
pub const EntryPoint = struct { pub const EntryPoint = struct {
/// The declaration that should be exported. /// The declaration that should be exported.
@ -165,18 +162,8 @@ decl_deps: std.ArrayListUnmanaged(Decl.Index) = .{},
/// The list of entry points that should be exported from this module. /// The list of entry points that should be exported from this module.
entry_points: std.ArrayListUnmanaged(EntryPoint) = .{}, entry_points: std.ArrayListUnmanaged(EntryPoint) = .{},
/// The fields in this structure help to maintain the required order for global variables.
globals: struct {
/// Set of globals, referred to by Decl.Index.
globals: std.AutoArrayHashMapUnmanaged(Decl.Index, Global) = .{},
/// This pseudo-section contains the initialization code for all the globals. Instructions from
/// here are reordered when flushing the module. Its contents should be part of the
/// `types_globals_constants` SPIR-V section when the module is emitted.
section: Section = .{},
} = .{},
/// The list of extended instruction sets that should be imported. /// The list of extended instruction sets that should be imported.
extended_instruction_set: std.AutoHashMapUnmanaged(ExtendedInstructionSet, IdRef) = .{}, extended_instruction_set: std.AutoHashMapUnmanaged(spec.InstructionSet, IdRef) = .{},
pub fn init(gpa: Allocator) Module { pub fn init(gpa: Allocator) Module {
return .{ return .{
@ -205,9 +192,6 @@ pub fn deinit(self: *Module) void {
self.entry_points.deinit(self.gpa); self.entry_points.deinit(self.gpa);
self.globals.globals.deinit(self.gpa);
self.globals.section.deinit(self.gpa);
self.extended_instruction_set.deinit(self.gpa); self.extended_instruction_set.deinit(self.gpa);
self.* = undefined; self.* = undefined;
@ -243,46 +227,6 @@ pub fn resolveString(self: *Module, str: []const u8) !CacheString {
return try self.cache.addString(self, str); return try self.cache.addString(self, str);
} }
fn orderGlobalsInto(
self: *Module,
decl_index: Decl.Index,
section: *Section,
seen: *std.DynamicBitSetUnmanaged,
) !void {
const decl = self.declPtr(decl_index);
const deps = self.decl_deps.items[decl.begin_dep..decl.end_dep];
const global = self.globalPtr(decl_index).?;
const insts = self.globals.section.instructions.items[global.begin_inst..global.end_inst];
seen.set(@intFromEnum(decl_index));
for (deps) |dep| {
if (!seen.isSet(@intFromEnum(dep))) {
try self.orderGlobalsInto(dep, section, seen);
}
}
try section.instructions.appendSlice(self.gpa, insts);
}
fn orderGlobals(self: *Module) !Section {
const globals = self.globals.globals.keys();
var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len);
defer seen.deinit(self.gpa);
var ordered_globals = Section{};
errdefer ordered_globals.deinit(self.gpa);
for (globals) |decl_index| {
if (!seen.isSet(@intFromEnum(decl_index))) {
try self.orderGlobalsInto(decl_index, &ordered_globals, &seen);
}
}
return ordered_globals;
}
fn addEntryPointDeps( fn addEntryPointDeps(
self: *Module, self: *Module,
decl_index: Decl.Index, decl_index: Decl.Index,
@ -298,8 +242,8 @@ fn addEntryPointDeps(
seen.set(@intFromEnum(decl_index)); seen.set(@intFromEnum(decl_index));
if (self.globalPtr(decl_index)) |global| { if (decl.kind == .global) {
try interface.append(global.result_id); try interface.append(decl.result_id);
} }
for (deps) |dep| { for (deps) |dep| {
@ -335,81 +279,9 @@ fn entryPoints(self: *Module) !Section {
return entry_points; return entry_points;
} }
/// Generate a function that calls all initialization functions, pub fn finalize(self: *Module, a: Allocator, target: std.Target) ![]Word {
/// in unspecified order (an order should not be required here).
/// It generated as follows:
/// %init = OpFunction %void None
/// foreach %initializer:
/// OpFunctionCall %initializer
/// OpReturn
/// OpFunctionEnd
fn initializer(self: *Module, entry_points: *Section) !Section {
var section = Section{};
errdefer section.deinit(self.gpa);
// const void_ty_ref = try self.resolveType(Type.void, .direct);
const void_ty_ref = try self.resolve(.void_type);
const void_ty_id = self.resultId(void_ty_ref);
const init_proto_ty_ref = try self.resolve(.{ .function_type = .{
.return_type = void_ty_ref,
.parameters = &.{},
} });
const init_id = self.allocId();
try section.emit(self.gpa, .OpFunction, .{
.id_result_type = void_ty_id,
.id_result = init_id,
.function_control = .{},
.function_type = self.resultId(init_proto_ty_ref),
});
try section.emit(self.gpa, .OpLabel, .{
.id_result = self.allocId(),
});
var seen = try std.DynamicBitSetUnmanaged.initEmpty(self.gpa, self.decls.items.len);
defer seen.deinit(self.gpa);
var interface = std.ArrayList(IdRef).init(self.gpa);
defer interface.deinit();
for (self.globals.globals.keys(), self.globals.globals.values()) |decl_index, global| {
try self.addEntryPointDeps(decl_index, &seen, &interface);
if (global.initializer_id) |initializer_id| {
try section.emit(self.gpa, .OpFunctionCall, .{
.id_result_type = void_ty_id,
.id_result = self.allocId(),
.function = initializer_id,
});
}
}
try section.emit(self.gpa, .OpReturn, {});
try section.emit(self.gpa, .OpFunctionEnd, {});
try entry_points.emit(self.gpa, .OpEntryPoint, .{
// TODO: Rusticl does not support this because its poorly defined.
// Do we need to generate a workaround here?
.execution_model = .Kernel,
.entry_point = init_id,
.name = "zig global initializer",
.interface = interface.items,
});
try self.sections.execution_modes.emit(self.gpa, .OpExecutionMode, .{
.entry_point = init_id,
.mode = .Initializer,
});
return section;
}
/// Emit this module as a spir-v binary.
pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void {
// See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction" // See SPIR-V Spec section 2.3, "Physical Layout of a SPIR-V Module and Instruction"
// TODO: Audit calls to allocId() in this function to make it idempotent.
// TODO: Perform topological sort on the globals.
var globals = try self.orderGlobals();
defer globals.deinit(self.gpa);
var entry_points = try self.entryPoints(); var entry_points = try self.entryPoints();
defer entry_points.deinit(self.gpa); defer entry_points.deinit(self.gpa);
@ -417,13 +289,6 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void {
var types_constants = try self.cache.materialize(self); var types_constants = try self.cache.materialize(self);
defer types_constants.deinit(self.gpa); defer types_constants.deinit(self.gpa);
// // TODO: Pass global variables as function parameters
// var init_func = if (target.os.tag != .vulkan)
// try self.initializer(&entry_points)
// else
// Section{};
// defer init_func.deinit(self.gpa);
const header = [_]Word{ const header = [_]Word{
spec.magic_number, spec.magic_number,
// TODO: From cpu features // TODO: From cpu features
@ -436,7 +301,7 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void {
else => 4, else => 4,
}, },
}), }),
0, // TODO: Register Zig compiler magic number. spec.zig_generator_id,
self.idBound(), self.idBound(),
0, // Schema (currently reserved for future use) 0, // Schema (currently reserved for future use)
}; };
@ -468,30 +333,23 @@ pub fn flush(self: *Module, file: std.fs.File, target: std.Target) !void {
self.sections.annotations.toWords(), self.sections.annotations.toWords(),
types_constants.toWords(), types_constants.toWords(),
self.sections.types_globals_constants.toWords(), self.sections.types_globals_constants.toWords(),
globals.toWords(),
self.sections.functions.toWords(), self.sections.functions.toWords(),
}; };
if (builtin.zig_backend == .stage2_x86_64) { var total_result_size: usize = 0;
for (buffers) |buf| { for (buffers) |buffer| {
try file.writeAll(std.mem.sliceAsBytes(buf)); total_result_size += buffer.len;
}
} else {
// miscompiles with x86_64 backend
var iovc_buffers: [buffers.len]std.os.iovec_const = undefined;
var file_size: u64 = 0;
for (&iovc_buffers, 0..) |*iovc, i| {
// Note, since spir-v supports both little and big endian we can ignore byte order here and
// just treat the words as a sequence of bytes.
const bytes = std.mem.sliceAsBytes(buffers[i]);
iovc.* = .{ .iov_base = bytes.ptr, .iov_len = bytes.len };
file_size += bytes.len;
}
try file.seekTo(0);
try file.setEndPos(file_size);
try file.pwritevAll(&iovc_buffers, 0);
} }
const result = try a.alloc(Word, total_result_size);
errdefer a.free(result);
var offset: usize = 0;
for (buffers) |buffer| {
@memcpy(result[offset..][0..buffer.len], buffer);
offset += buffer.len;
}
return result;
} }
/// Merge the sections making up a function declaration into this module. /// Merge the sections making up a function declaration into this module.
@ -501,23 +359,17 @@ pub fn addFunction(self: *Module, decl_index: Decl.Index, func: Fn) !void {
try self.declareDeclDeps(decl_index, func.decl_deps.keys()); try self.declareDeclDeps(decl_index, func.decl_deps.keys());
} }
pub const ExtendedInstructionSet = enum {
glsl,
opencl,
};
/// Imports or returns the existing id of an extended instruction set /// Imports or returns the existing id of an extended instruction set
pub fn importInstructionSet(self: *Module, set: ExtendedInstructionSet) !IdRef { pub fn importInstructionSet(self: *Module, set: spec.InstructionSet) !IdRef {
assert(set != .core);
const gop = try self.extended_instruction_set.getOrPut(self.gpa, set); const gop = try self.extended_instruction_set.getOrPut(self.gpa, set);
if (gop.found_existing) return gop.value_ptr.*; if (gop.found_existing) return gop.value_ptr.*;
const result_id = self.allocId(); const result_id = self.allocId();
try self.sections.extended_instruction_set.emit(self.gpa, .OpExtInstImport, .{ try self.sections.extended_instruction_set.emit(self.gpa, .OpExtInstImport, .{
.id_result = result_id, .id_result = result_id,
.name = switch (set) { .name = @tagName(set),
.glsl => "GLSL.std.450",
.opencl => "OpenCL.std",
},
}); });
gop.value_ptr.* = result_id; gop.value_ptr.* = result_id;
@ -631,40 +483,21 @@ pub fn decorateMember(
}); });
} }
pub const DeclKind = enum { pub fn allocDecl(self: *Module, kind: Decl.Kind) !Decl.Index {
func,
global,
};
pub fn allocDecl(self: *Module, kind: DeclKind) !Decl.Index {
try self.decls.append(self.gpa, .{ try self.decls.append(self.gpa, .{
.kind = kind,
.result_id = self.allocId(), .result_id = self.allocId(),
.begin_dep = undefined, .begin_dep = undefined,
.end_dep = undefined, .end_dep = undefined,
}); });
const index = @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1))));
switch (kind) {
.func => {},
// If the decl represents a global, also allocate a global node.
.global => try self.globals.globals.putNoClobber(self.gpa, index, .{
.result_id = undefined,
.begin_inst = undefined,
.end_inst = undefined,
.initializer_id = undefined,
}),
}
return index; return @as(Decl.Index, @enumFromInt(@as(u32, @intCast(self.decls.items.len - 1))));
} }
pub fn declPtr(self: *Module, index: Decl.Index) *Decl { pub fn declPtr(self: *Module, index: Decl.Index) *Decl {
return &self.decls.items[@intFromEnum(index)]; return &self.decls.items[@intFromEnum(index)];
} }
pub fn globalPtr(self: *Module, index: Decl.Index) ?*Global {
return self.globals.globals.getPtr(index);
}
/// Declare ALL dependencies for a decl. /// Declare ALL dependencies for a decl.
pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl.Index) !void { pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl.Index) !void {
const begin_dep = @as(u32, @intCast(self.decl_deps.items.len)); const begin_dep = @as(u32, @intCast(self.decl_deps.items.len));
@ -676,26 +509,9 @@ pub fn declareDeclDeps(self: *Module, decl_index: Decl.Index, deps: []const Decl
decl.end_dep = end_dep; decl.end_dep = end_dep;
} }
pub fn beginGlobal(self: *Module) u32 { /// Declare a SPIR-V function as an entry point. This causes an extra wrapper
return @as(u32, @intCast(self.globals.section.instructions.items.len)); /// function to be generated, which is then exported as the real entry point. The purpose of this
} /// wrapper is to allocate and initialize the structure holding the instance globals.
pub fn endGlobal(
self: *Module,
global_index: Decl.Index,
begin_inst: u32,
result_id: IdRef,
initializer_id: ?IdRef,
) void {
const global = self.globalPtr(global_index).?;
global.* = .{
.result_id = result_id,
.begin_inst = begin_inst,
.end_inst = @intCast(self.globals.section.instructions.items.len),
.initializer_id = initializer_id,
};
}
pub fn declareEntryPoint( pub fn declareEntryPoint(
self: *Module, self: *Module,
decl_index: Decl.Index, decl_index: Decl.Index,

View File

@ -53,6 +53,17 @@ pub fn emitRaw(
section.writeWord((@as(Word, @intCast(word_count << 16))) | @intFromEnum(opcode)); section.writeWord((@as(Word, @intCast(word_count << 16))) | @intFromEnum(opcode));
} }
/// Write an entire instruction, including all operands
pub fn emitRawInstruction(
section: *Section,
allocator: Allocator,
opcode: Opcode,
operands: []const Word,
) !void {
try section.emitRaw(allocator, opcode, operands.len);
section.writeWords(operands);
}
pub fn emit( pub fn emit(
section: *Section, section: *Section,
allocator: Allocator, allocator: Allocator,

View File

@ -1,5 +1,7 @@
//! This file is auto-generated by tools/gen_spirv_spec.zig. //! This file is auto-generated by tools/gen_spirv_spec.zig.
const std = @import("std");
pub const Version = packed struct(Word) { pub const Version = packed struct(Word) {
padding: u8 = 0, padding: u8 = 0,
minor: u8, minor: u8,
@ -15,6 +17,18 @@ pub const Word = u32;
pub const IdResult = enum(Word) { pub const IdResult = enum(Word) {
none, none,
_, _,
pub fn format(
self: IdResult,
comptime _: []const u8,
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
switch (self) {
.none => try writer.writeAll("(none)"),
else => try writer.print("%{}", .{@intFromEnum(self)}),
}
}
}; };
pub const IdResultType = IdResult; pub const IdResultType = IdResult;
pub const IdRef = IdResult; pub const IdRef = IdResult;
@ -70,6 +84,7 @@ pub const Instruction = struct {
operands: []const Operand, operands: []const Operand,
}; };
pub const zig_generator_id: Word = 41;
pub const version = Version{ .major = 1, .minor = 6, .patch = 1 }; pub const version = Version{ .major = 1, .minor = 6, .patch = 1 };
pub const magic_number: Word = 0x07230203; pub const magic_number: Word = 0x07230203;
@ -166,25 +181,25 @@ pub const OperandKind = enum {
PairLiteralIntegerIdRef, PairLiteralIntegerIdRef,
PairIdRefLiteralInteger, PairIdRefLiteralInteger,
PairIdRefIdRef, PairIdRefIdRef,
@"opencl.debuginfo.100.DebugInfoFlags", @"OpenCL.DebugInfo.100.DebugInfoFlags",
@"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding", @"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding",
@"opencl.debuginfo.100.DebugCompositeType", @"OpenCL.DebugInfo.100.DebugCompositeType",
@"opencl.debuginfo.100.DebugTypeQualifier", @"OpenCL.DebugInfo.100.DebugTypeQualifier",
@"opencl.debuginfo.100.DebugOperation", @"OpenCL.DebugInfo.100.DebugOperation",
@"opencl.debuginfo.100.DebugImportedEntity", @"OpenCL.DebugInfo.100.DebugImportedEntity",
@"nonsemantic.shader.debuginfo.100.DebugInfoFlags", @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags",
@"nonsemantic.shader.debuginfo.100.BuildIdentifierFlags", @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags",
@"nonsemantic.shader.debuginfo.100.DebugBaseTypeAttributeEncoding", @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding",
@"nonsemantic.shader.debuginfo.100.DebugCompositeType", @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType",
@"nonsemantic.shader.debuginfo.100.DebugTypeQualifier", @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier",
@"nonsemantic.shader.debuginfo.100.DebugOperation", @"NonSemantic.Shader.DebugInfo.100.DebugOperation",
@"nonsemantic.shader.debuginfo.100.DebugImportedEntity", @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity",
@"nonsemantic.clspvreflection.KernelPropertyFlags", @"NonSemantic.ClspvReflection.6.KernelPropertyFlags",
@"debuginfo.DebugInfoFlags", @"DebugInfo.DebugInfoFlags",
@"debuginfo.DebugBaseTypeAttributeEncoding", @"DebugInfo.DebugBaseTypeAttributeEncoding",
@"debuginfo.DebugCompositeType", @"DebugInfo.DebugCompositeType",
@"debuginfo.DebugTypeQualifier", @"DebugInfo.DebugTypeQualifier",
@"debuginfo.DebugOperation", @"DebugInfo.DebugOperation",
pub fn category(self: OperandKind) OperandCategory { pub fn category(self: OperandKind) OperandCategory {
return switch (self) { return switch (self) {
@ -252,25 +267,25 @@ pub const OperandKind = enum {
.PairLiteralIntegerIdRef => .composite, .PairLiteralIntegerIdRef => .composite,
.PairIdRefLiteralInteger => .composite, .PairIdRefLiteralInteger => .composite,
.PairIdRefIdRef => .composite, .PairIdRefIdRef => .composite,
.@"opencl.debuginfo.100.DebugInfoFlags" => .bit_enum, .@"OpenCL.DebugInfo.100.DebugInfoFlags" => .bit_enum,
.@"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding" => .value_enum, .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" => .value_enum,
.@"opencl.debuginfo.100.DebugCompositeType" => .value_enum, .@"OpenCL.DebugInfo.100.DebugCompositeType" => .value_enum,
.@"opencl.debuginfo.100.DebugTypeQualifier" => .value_enum, .@"OpenCL.DebugInfo.100.DebugTypeQualifier" => .value_enum,
.@"opencl.debuginfo.100.DebugOperation" => .value_enum, .@"OpenCL.DebugInfo.100.DebugOperation" => .value_enum,
.@"opencl.debuginfo.100.DebugImportedEntity" => .value_enum, .@"OpenCL.DebugInfo.100.DebugImportedEntity" => .value_enum,
.@"nonsemantic.shader.debuginfo.100.DebugInfoFlags" => .bit_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" => .bit_enum,
.@"nonsemantic.shader.debuginfo.100.BuildIdentifierFlags" => .bit_enum, .@"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" => .bit_enum,
.@"nonsemantic.shader.debuginfo.100.DebugBaseTypeAttributeEncoding" => .value_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" => .value_enum,
.@"nonsemantic.shader.debuginfo.100.DebugCompositeType" => .value_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" => .value_enum,
.@"nonsemantic.shader.debuginfo.100.DebugTypeQualifier" => .value_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" => .value_enum,
.@"nonsemantic.shader.debuginfo.100.DebugOperation" => .value_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugOperation" => .value_enum,
.@"nonsemantic.shader.debuginfo.100.DebugImportedEntity" => .value_enum, .@"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" => .value_enum,
.@"nonsemantic.clspvreflection.KernelPropertyFlags" => .bit_enum, .@"NonSemantic.ClspvReflection.6.KernelPropertyFlags" => .bit_enum,
.@"debuginfo.DebugInfoFlags" => .bit_enum, .@"DebugInfo.DebugInfoFlags" => .bit_enum,
.@"debuginfo.DebugBaseTypeAttributeEncoding" => .value_enum, .@"DebugInfo.DebugBaseTypeAttributeEncoding" => .value_enum,
.@"debuginfo.DebugCompositeType" => .value_enum, .@"DebugInfo.DebugCompositeType" => .value_enum,
.@"debuginfo.DebugTypeQualifier" => .value_enum, .@"DebugInfo.DebugTypeQualifier" => .value_enum,
.@"debuginfo.DebugOperation" => .value_enum, .@"DebugInfo.DebugOperation" => .value_enum,
}; };
} }
pub fn enumerants(self: OperandKind) []const Enumerant { pub fn enumerants(self: OperandKind) []const Enumerant {
@ -1395,7 +1410,7 @@ pub const OperandKind = enum {
.PairLiteralIntegerIdRef => unreachable, .PairLiteralIntegerIdRef => unreachable,
.PairIdRefLiteralInteger => unreachable, .PairIdRefLiteralInteger => unreachable,
.PairIdRefIdRef => unreachable, .PairIdRefIdRef => unreachable,
.@"opencl.debuginfo.100.DebugInfoFlags" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugInfoFlags" => &[_]Enumerant{
.{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} },
@ -1415,7 +1430,7 @@ pub const OperandKind = enum {
.{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagTypePassByValue", .value = 0x8000, .parameters = &[_]OperandKind{} },
.{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} },
}, },
.@"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{
.{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} },
@ -1425,18 +1440,18 @@ pub const OperandKind = enum {
.{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} }, .{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} },
.{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} }, .{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} },
}, },
.@"opencl.debuginfo.100.DebugCompositeType" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugCompositeType" => &[_]Enumerant{
.{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} },
}, },
.@"opencl.debuginfo.100.DebugTypeQualifier" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugTypeQualifier" => &[_]Enumerant{
.{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} },
.{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} }, .{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} },
}, },
.@"opencl.debuginfo.100.DebugOperation" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugOperation" => &[_]Enumerant{
.{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} },
@ -1448,11 +1463,11 @@ pub const OperandKind = enum {
.{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.LiteralInteger} }, .{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.LiteralInteger} },
.{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } }, .{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .LiteralInteger, .LiteralInteger } },
}, },
.@"opencl.debuginfo.100.DebugImportedEntity" => &[_]Enumerant{ .@"OpenCL.DebugInfo.100.DebugImportedEntity" => &[_]Enumerant{
.{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugInfoFlags" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" => &[_]Enumerant{
.{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} },
@ -1473,10 +1488,10 @@ pub const OperandKind = enum {
.{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagTypePassByReference", .value = 0x10000, .parameters = &[_]OperandKind{} },
.{ .name = "FlagUnknownPhysicalLayout", .value = 0x20000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagUnknownPhysicalLayout", .value = 0x20000, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.BuildIdentifierFlags" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" => &[_]Enumerant{
.{ .name = "IdentifierPossibleDuplicates", .value = 0x01, .parameters = &[_]OperandKind{} }, .{ .name = "IdentifierPossibleDuplicates", .value = 0x01, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{
.{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} },
@ -1486,18 +1501,18 @@ pub const OperandKind = enum {
.{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} }, .{ .name = "Unsigned", .value = 6, .parameters = &[_]OperandKind{} },
.{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} }, .{ .name = "UnsignedChar", .value = 7, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugCompositeType" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" => &[_]Enumerant{
.{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugTypeQualifier" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" => &[_]Enumerant{
.{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} },
.{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} }, .{ .name = "AtomicType", .value = 3, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugOperation" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugOperation" => &[_]Enumerant{
.{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} },
@ -1509,14 +1524,14 @@ pub const OperandKind = enum {
.{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.IdRef} }, .{ .name = "Constu", .value = 8, .parameters = &[_]OperandKind{.IdRef} },
.{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .IdRef, .IdRef } }, .{ .name = "Fragment", .value = 9, .parameters = &[_]OperandKind{ .IdRef, .IdRef } },
}, },
.@"nonsemantic.shader.debuginfo.100.DebugImportedEntity" => &[_]Enumerant{ .@"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" => &[_]Enumerant{
.{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ImportedModule", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "ImportedDeclaration", .value = 1, .parameters = &[_]OperandKind{} },
}, },
.@"nonsemantic.clspvreflection.KernelPropertyFlags" => &[_]Enumerant{ .@"NonSemantic.ClspvReflection.6.KernelPropertyFlags" => &[_]Enumerant{
.{ .name = "MayUsePrintf", .value = 0x1, .parameters = &[_]OperandKind{} }, .{ .name = "MayUsePrintf", .value = 0x1, .parameters = &[_]OperandKind{} },
}, },
.@"debuginfo.DebugInfoFlags" => &[_]Enumerant{ .@"DebugInfo.DebugInfoFlags" => &[_]Enumerant{
.{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsProtected", .value = 0x01, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPrivate", .value = 0x02, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsPublic", .value = 0x03, .parameters = &[_]OperandKind{} },
@ -1533,7 +1548,7 @@ pub const OperandKind = enum {
.{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagRValueReference", .value = 0x1000, .parameters = &[_]OperandKind{} },
.{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &[_]OperandKind{} }, .{ .name = "FlagIsOptimized", .value = 0x2000, .parameters = &[_]OperandKind{} },
}, },
.@"debuginfo.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{ .@"DebugInfo.DebugBaseTypeAttributeEncoding" => &[_]Enumerant{
.{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Unspecified", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Address", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Boolean", .value = 2, .parameters = &[_]OperandKind{} },
@ -1543,17 +1558,17 @@ pub const OperandKind = enum {
.{ .name = "Unsigned", .value = 7, .parameters = &[_]OperandKind{} }, .{ .name = "Unsigned", .value = 7, .parameters = &[_]OperandKind{} },
.{ .name = "UnsignedChar", .value = 8, .parameters = &[_]OperandKind{} }, .{ .name = "UnsignedChar", .value = 8, .parameters = &[_]OperandKind{} },
}, },
.@"debuginfo.DebugCompositeType" => &[_]Enumerant{ .@"DebugInfo.DebugCompositeType" => &[_]Enumerant{
.{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Class", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Structure", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Union", .value = 2, .parameters = &[_]OperandKind{} },
}, },
.@"debuginfo.DebugTypeQualifier" => &[_]Enumerant{ .@"DebugInfo.DebugTypeQualifier" => &[_]Enumerant{
.{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "ConstType", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "VolatileType", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "RestrictType", .value = 2, .parameters = &[_]OperandKind{} },
}, },
.@"debuginfo.DebugOperation" => &[_]Enumerant{ .@"DebugInfo.DebugOperation" => &[_]Enumerant{
.{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} }, .{ .name = "Deref", .value = 0, .parameters = &[_]OperandKind{} },
.{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} }, .{ .name = "Plus", .value = 1, .parameters = &[_]OperandKind{} },
.{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} }, .{ .name = "Minus", .value = 2, .parameters = &[_]OperandKind{} },
@ -4952,7 +4967,7 @@ pub const StoreCacheControl = enum(u32) {
pub const NamedMaximumNumberOfRegisters = enum(u32) { pub const NamedMaximumNumberOfRegisters = enum(u32) {
AutoINTEL = 0, AutoINTEL = 0,
}; };
pub const @"opencl.debuginfo.100.DebugInfoFlags" = packed struct { pub const @"OpenCL.DebugInfo.100.DebugInfoFlags" = packed struct {
FlagIsProtected: bool = false, FlagIsProtected: bool = false,
FlagIsPrivate: bool = false, FlagIsPrivate: bool = false,
FlagIsLocal: bool = false, FlagIsLocal: bool = false,
@ -4986,7 +5001,7 @@ pub const @"opencl.debuginfo.100.DebugInfoFlags" = packed struct {
_reserved_bit_30: bool = false, _reserved_bit_30: bool = false,
_reserved_bit_31: bool = false, _reserved_bit_31: bool = false,
}; };
pub const @"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) { pub const @"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) {
Unspecified = 0, Unspecified = 0,
Address = 1, Address = 1,
Boolean = 2, Boolean = 2,
@ -4996,18 +5011,18 @@ pub const @"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) {
Unsigned = 6, Unsigned = 6,
UnsignedChar = 7, UnsignedChar = 7,
}; };
pub const @"opencl.debuginfo.100.DebugCompositeType" = enum(u32) { pub const @"OpenCL.DebugInfo.100.DebugCompositeType" = enum(u32) {
Class = 0, Class = 0,
Structure = 1, Structure = 1,
Union = 2, Union = 2,
}; };
pub const @"opencl.debuginfo.100.DebugTypeQualifier" = enum(u32) { pub const @"OpenCL.DebugInfo.100.DebugTypeQualifier" = enum(u32) {
ConstType = 0, ConstType = 0,
VolatileType = 1, VolatileType = 1,
RestrictType = 2, RestrictType = 2,
AtomicType = 3, AtomicType = 3,
}; };
pub const @"opencl.debuginfo.100.DebugOperation" = enum(u32) { pub const @"OpenCL.DebugInfo.100.DebugOperation" = enum(u32) {
Deref = 0, Deref = 0,
Plus = 1, Plus = 1,
Minus = 2, Minus = 2,
@ -5019,7 +5034,7 @@ pub const @"opencl.debuginfo.100.DebugOperation" = enum(u32) {
Constu = 8, Constu = 8,
Fragment = 9, Fragment = 9,
pub const Extended = union(@"opencl.debuginfo.100.DebugOperation") { pub const Extended = union(@"OpenCL.DebugInfo.100.DebugOperation") {
Deref, Deref,
Plus, Plus,
Minus, Minus,
@ -5032,11 +5047,11 @@ pub const @"opencl.debuginfo.100.DebugOperation" = enum(u32) {
Fragment: struct { literal_integer_0: LiteralInteger, literal_integer_1: LiteralInteger }, Fragment: struct { literal_integer_0: LiteralInteger, literal_integer_1: LiteralInteger },
}; };
}; };
pub const @"opencl.debuginfo.100.DebugImportedEntity" = enum(u32) { pub const @"OpenCL.DebugInfo.100.DebugImportedEntity" = enum(u32) {
ImportedModule = 0, ImportedModule = 0,
ImportedDeclaration = 1, ImportedDeclaration = 1,
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugInfoFlags" = packed struct { pub const @"NonSemantic.Shader.DebugInfo.100.DebugInfoFlags" = packed struct {
FlagIsProtected: bool = false, FlagIsProtected: bool = false,
FlagIsPrivate: bool = false, FlagIsPrivate: bool = false,
FlagIsLocal: bool = false, FlagIsLocal: bool = false,
@ -5070,7 +5085,7 @@ pub const @"nonsemantic.shader.debuginfo.100.DebugInfoFlags" = packed struct {
_reserved_bit_30: bool = false, _reserved_bit_30: bool = false,
_reserved_bit_31: bool = false, _reserved_bit_31: bool = false,
}; };
pub const @"nonsemantic.shader.debuginfo.100.BuildIdentifierFlags" = packed struct { pub const @"NonSemantic.Shader.DebugInfo.100.BuildIdentifierFlags" = packed struct {
IdentifierPossibleDuplicates: bool = false, IdentifierPossibleDuplicates: bool = false,
_reserved_bit_1: bool = false, _reserved_bit_1: bool = false,
_reserved_bit_2: bool = false, _reserved_bit_2: bool = false,
@ -5104,7 +5119,7 @@ pub const @"nonsemantic.shader.debuginfo.100.BuildIdentifierFlags" = packed stru
_reserved_bit_30: bool = false, _reserved_bit_30: bool = false,
_reserved_bit_31: bool = false, _reserved_bit_31: bool = false,
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) { pub const @"NonSemantic.Shader.DebugInfo.100.DebugBaseTypeAttributeEncoding" = enum(u32) {
Unspecified = 0, Unspecified = 0,
Address = 1, Address = 1,
Boolean = 2, Boolean = 2,
@ -5114,18 +5129,18 @@ pub const @"nonsemantic.shader.debuginfo.100.DebugBaseTypeAttributeEncoding" = e
Unsigned = 6, Unsigned = 6,
UnsignedChar = 7, UnsignedChar = 7,
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugCompositeType" = enum(u32) { pub const @"NonSemantic.Shader.DebugInfo.100.DebugCompositeType" = enum(u32) {
Class = 0, Class = 0,
Structure = 1, Structure = 1,
Union = 2, Union = 2,
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugTypeQualifier" = enum(u32) { pub const @"NonSemantic.Shader.DebugInfo.100.DebugTypeQualifier" = enum(u32) {
ConstType = 0, ConstType = 0,
VolatileType = 1, VolatileType = 1,
RestrictType = 2, RestrictType = 2,
AtomicType = 3, AtomicType = 3,
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugOperation" = enum(u32) { pub const @"NonSemantic.Shader.DebugInfo.100.DebugOperation" = enum(u32) {
Deref = 0, Deref = 0,
Plus = 1, Plus = 1,
Minus = 2, Minus = 2,
@ -5137,7 +5152,7 @@ pub const @"nonsemantic.shader.debuginfo.100.DebugOperation" = enum(u32) {
Constu = 8, Constu = 8,
Fragment = 9, Fragment = 9,
pub const Extended = union(@"nonsemantic.shader.debuginfo.100.DebugOperation") { pub const Extended = union(@"NonSemantic.Shader.DebugInfo.100.DebugOperation") {
Deref, Deref,
Plus, Plus,
Minus, Minus,
@ -5150,11 +5165,11 @@ pub const @"nonsemantic.shader.debuginfo.100.DebugOperation" = enum(u32) {
Fragment: struct { id_ref_0: IdRef, id_ref_1: IdRef }, Fragment: struct { id_ref_0: IdRef, id_ref_1: IdRef },
}; };
}; };
pub const @"nonsemantic.shader.debuginfo.100.DebugImportedEntity" = enum(u32) { pub const @"NonSemantic.Shader.DebugInfo.100.DebugImportedEntity" = enum(u32) {
ImportedModule = 0, ImportedModule = 0,
ImportedDeclaration = 1, ImportedDeclaration = 1,
}; };
pub const @"nonsemantic.clspvreflection.KernelPropertyFlags" = packed struct { pub const @"NonSemantic.ClspvReflection.6.KernelPropertyFlags" = packed struct {
MayUsePrintf: bool = false, MayUsePrintf: bool = false,
_reserved_bit_1: bool = false, _reserved_bit_1: bool = false,
_reserved_bit_2: bool = false, _reserved_bit_2: bool = false,
@ -5188,7 +5203,7 @@ pub const @"nonsemantic.clspvreflection.KernelPropertyFlags" = packed struct {
_reserved_bit_30: bool = false, _reserved_bit_30: bool = false,
_reserved_bit_31: bool = false, _reserved_bit_31: bool = false,
}; };
pub const @"debuginfo.DebugInfoFlags" = packed struct { pub const @"DebugInfo.DebugInfoFlags" = packed struct {
FlagIsProtected: bool = false, FlagIsProtected: bool = false,
FlagIsPrivate: bool = false, FlagIsPrivate: bool = false,
FlagIsLocal: bool = false, FlagIsLocal: bool = false,
@ -5222,7 +5237,7 @@ pub const @"debuginfo.DebugInfoFlags" = packed struct {
_reserved_bit_30: bool = false, _reserved_bit_30: bool = false,
_reserved_bit_31: bool = false, _reserved_bit_31: bool = false,
}; };
pub const @"debuginfo.DebugBaseTypeAttributeEncoding" = enum(u32) { pub const @"DebugInfo.DebugBaseTypeAttributeEncoding" = enum(u32) {
Unspecified = 0, Unspecified = 0,
Address = 1, Address = 1,
Boolean = 2, Boolean = 2,
@ -5232,17 +5247,17 @@ pub const @"debuginfo.DebugBaseTypeAttributeEncoding" = enum(u32) {
Unsigned = 7, Unsigned = 7,
UnsignedChar = 8, UnsignedChar = 8,
}; };
pub const @"debuginfo.DebugCompositeType" = enum(u32) { pub const @"DebugInfo.DebugCompositeType" = enum(u32) {
Class = 0, Class = 0,
Structure = 1, Structure = 1,
Union = 2, Union = 2,
}; };
pub const @"debuginfo.DebugTypeQualifier" = enum(u32) { pub const @"DebugInfo.DebugTypeQualifier" = enum(u32) {
ConstType = 0, ConstType = 0,
VolatileType = 1, VolatileType = 1,
RestrictType = 2, RestrictType = 2,
}; };
pub const @"debuginfo.DebugOperation" = enum(u32) { pub const @"DebugInfo.DebugOperation" = enum(u32) {
Deref = 0, Deref = 0,
Plus = 1, Plus = 1,
Minus = 2, Minus = 2,
@ -5253,7 +5268,7 @@ pub const @"debuginfo.DebugOperation" = enum(u32) {
StackValue = 7, StackValue = 7,
Constu = 8, Constu = 8,
pub const Extended = union(@"debuginfo.DebugOperation") { pub const Extended = union(@"DebugInfo.DebugOperation") {
Deref, Deref,
Plus, Plus,
Minus, Minus,
@ -5267,19 +5282,19 @@ pub const @"debuginfo.DebugOperation" = enum(u32) {
}; };
pub const InstructionSet = enum { pub const InstructionSet = enum {
core, core,
@"opencl.std.100", @"OpenCL.std",
@"glsl.std.450", @"GLSL.std.450",
@"opencl.debuginfo.100", @"OpenCL.DebugInfo.100",
@"spv-amd-shader-ballot", SPV_AMD_shader_ballot,
@"nonsemantic.shader.debuginfo.100", @"NonSemantic.Shader.DebugInfo.100",
@"nonsemantic.vkspreflection", @"NonSemantic.VkspReflection",
@"nonsemantic.clspvreflection", @"NonSemantic.ClspvReflection.6",
@"spv-amd-gcn-shader", SPV_AMD_gcn_shader,
@"spv-amd-shader-trinary-minmax", SPV_AMD_shader_trinary_minmax,
debuginfo, DebugInfo,
@"nonsemantic.debugprintf", @"NonSemantic.DebugPrintf",
@"spv-amd-shader-explicit-vertex-parameter", SPV_AMD_shader_explicit_vertex_parameter,
@"nonsemantic.debugbreak", @"NonSemantic.DebugBreak",
zig, zig,
pub fn instructions(self: InstructionSet) []const Instruction { pub fn instructions(self: InstructionSet) []const Instruction {
@ -12775,7 +12790,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"opencl.std.100" => &[_]Instruction{ .@"OpenCL.std" => &[_]Instruction{
.{ .{
.name = "acos", .name = "acos",
.opcode = 0, .opcode = 0,
@ -14025,7 +14040,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"glsl.std.450" => &[_]Instruction{ .@"GLSL.std.450" => &[_]Instruction{
.{ .{
.name = "Round", .name = "Round",
.opcode = 1, .opcode = 1,
@ -14633,7 +14648,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"opencl.debuginfo.100" => &[_]Instruction{ .@"OpenCL.DebugInfo.100" => &[_]Instruction{
.{ .{
.name = "DebugInfoNone", .name = "DebugInfoNone",
.opcode = 0, .opcode = 0,
@ -14655,7 +14670,7 @@ pub const InstructionSet = enum {
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugBaseTypeAttributeEncoding", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugBaseTypeAttributeEncoding", .quantifier = .required },
}, },
}, },
.{ .{
@ -14664,7 +14679,7 @@ pub const InstructionSet = enum {
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .StorageClass, .quantifier = .required }, .{ .kind = .StorageClass, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -14672,7 +14687,7 @@ pub const InstructionSet = enum {
.opcode = 4, .opcode = 4,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugTypeQualifier", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugTypeQualifier", .quantifier = .required },
}, },
}, },
.{ .{
@ -14707,7 +14722,7 @@ pub const InstructionSet = enum {
.name = "DebugTypeFunction", .name = "DebugTypeFunction",
.opcode = 8, .opcode = 8,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .variadic }, .{ .kind = .IdRef, .quantifier = .variadic },
}, },
@ -14723,7 +14738,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, .{ .kind = .PairIdRefIdRef, .quantifier = .variadic },
}, },
}, },
@ -14732,14 +14747,14 @@ pub const InstructionSet = enum {
.opcode = 10, .opcode = 10,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugCompositeType", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugCompositeType", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .variadic }, .{ .kind = .IdRef, .quantifier = .variadic },
}, },
}, },
@ -14755,7 +14770,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
}, },
}, },
@ -14767,7 +14782,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -14832,7 +14847,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
}, },
}, },
@ -14847,7 +14862,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -14861,7 +14876,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
@ -14919,7 +14934,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugInfoFlags", .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .optional }, .{ .kind = .LiteralInteger, .quantifier = .optional },
}, },
}, },
@ -14954,7 +14969,7 @@ pub const InstructionSet = enum {
.name = "DebugOperation", .name = "DebugOperation",
.opcode = 30, .opcode = 30,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .@"opencl.debuginfo.100.DebugOperation", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugOperation", .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .variadic }, .{ .kind = .LiteralInteger, .quantifier = .variadic },
}, },
}, },
@ -14989,7 +15004,7 @@ pub const InstructionSet = enum {
.opcode = 34, .opcode = 34,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"opencl.debuginfo.100.DebugImportedEntity", .quantifier = .required }, .{ .kind = .@"OpenCL.DebugInfo.100.DebugImportedEntity", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
@ -15020,7 +15035,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"spv-amd-shader-ballot" => &[_]Instruction{ .SPV_AMD_shader_ballot => &[_]Instruction{
.{ .{
.name = "SwizzleInvocationsAMD", .name = "SwizzleInvocationsAMD",
.opcode = 1, .opcode = 1,
@ -15054,7 +15069,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"nonsemantic.shader.debuginfo.100" => &[_]Instruction{ .@"NonSemantic.Shader.DebugInfo.100" => &[_]Instruction{
.{ .{
.name = "DebugInfoNone", .name = "DebugInfoNone",
.opcode = 0, .opcode = 0,
@ -15491,7 +15506,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"nonsemantic.vkspreflection" => &[_]Instruction{ .@"NonSemantic.VkspReflection" => &[_]Instruction{
.{ .{
.name = "Configuration", .name = "Configuration",
.opcode = 1, .opcode = 1,
@ -15623,7 +15638,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"nonsemantic.clspvreflection" => &[_]Instruction{ .@"NonSemantic.ClspvReflection.6" => &[_]Instruction{
.{ .{
.name = "Kernel", .name = "Kernel",
.opcode = 1, .opcode = 1,
@ -16030,7 +16045,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"spv-amd-gcn-shader" => &[_]Instruction{ .SPV_AMD_gcn_shader => &[_]Instruction{
.{ .{
.name = "CubeFaceIndexAMD", .name = "CubeFaceIndexAMD",
.opcode = 1, .opcode = 1,
@ -16051,7 +16066,7 @@ pub const InstructionSet = enum {
.operands = &[_]Operand{}, .operands = &[_]Operand{},
}, },
}, },
.@"spv-amd-shader-trinary-minmax" => &[_]Instruction{ .SPV_AMD_shader_trinary_minmax => &[_]Instruction{
.{ .{
.name = "FMin3AMD", .name = "FMin3AMD",
.opcode = 1, .opcode = 1,
@ -16134,7 +16149,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.debuginfo => &[_]Instruction{ .DebugInfo => &[_]Instruction{
.{ .{
.name = "DebugInfoNone", .name = "DebugInfoNone",
.opcode = 0, .opcode = 0,
@ -16155,7 +16170,7 @@ pub const InstructionSet = enum {
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugBaseTypeAttributeEncoding", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugBaseTypeAttributeEncoding", .quantifier = .required },
}, },
}, },
.{ .{
@ -16164,7 +16179,7 @@ pub const InstructionSet = enum {
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .StorageClass, .quantifier = .required }, .{ .kind = .StorageClass, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -16172,7 +16187,7 @@ pub const InstructionSet = enum {
.opcode = 4, .opcode = 4,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugTypeQualifier", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugTypeQualifier", .quantifier = .required },
}, },
}, },
.{ .{
@ -16222,7 +16237,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
.{ .kind = .PairIdRefIdRef, .quantifier = .variadic }, .{ .kind = .PairIdRefIdRef, .quantifier = .variadic },
}, },
}, },
@ -16231,13 +16246,13 @@ pub const InstructionSet = enum {
.opcode = 10, .opcode = 10,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugCompositeType", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugCompositeType", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .variadic }, .{ .kind = .IdRef, .quantifier = .variadic },
}, },
}, },
@ -16253,7 +16268,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
}, },
}, },
@ -16265,7 +16280,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -16330,7 +16345,7 @@ pub const InstructionSet = enum {
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
}, },
}, },
@ -16345,7 +16360,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
}, },
}, },
.{ .{
@ -16359,7 +16374,7 @@ pub const InstructionSet = enum {
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .@"debuginfo.DebugInfoFlags", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugInfoFlags", .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .required }, .{ .kind = .LiteralInteger, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .required }, .{ .kind = .IdRef, .quantifier = .required },
.{ .kind = .IdRef, .quantifier = .optional }, .{ .kind = .IdRef, .quantifier = .optional },
@ -16450,7 +16465,7 @@ pub const InstructionSet = enum {
.name = "DebugOperation", .name = "DebugOperation",
.opcode = 30, .opcode = 30,
.operands = &[_]Operand{ .operands = &[_]Operand{
.{ .kind = .@"debuginfo.DebugOperation", .quantifier = .required }, .{ .kind = .@"DebugInfo.DebugOperation", .quantifier = .required },
.{ .kind = .LiteralInteger, .quantifier = .variadic }, .{ .kind = .LiteralInteger, .quantifier = .variadic },
}, },
}, },
@ -16481,7 +16496,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"nonsemantic.debugprintf" => &[_]Instruction{ .@"NonSemantic.DebugPrintf" => &[_]Instruction{
.{ .{
.name = "DebugPrintf", .name = "DebugPrintf",
.opcode = 1, .opcode = 1,
@ -16491,7 +16506,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"spv-amd-shader-explicit-vertex-parameter" => &[_]Instruction{ .SPV_AMD_shader_explicit_vertex_parameter => &[_]Instruction{
.{ .{
.name = "InterpolateAtVertexAMD", .name = "InterpolateAtVertexAMD",
.opcode = 1, .opcode = 1,
@ -16501,7 +16516,7 @@ pub const InstructionSet = enum {
}, },
}, },
}, },
.@"nonsemantic.debugbreak" => &[_]Instruction{ .@"NonSemantic.DebugBreak" => &[_]Instruction{
.{ .{
.name = "DebugBreak", .name = "DebugBreak",
.opcode = 1, .opcode = 1,

View File

@ -39,8 +39,12 @@ const Liveness = @import("../Liveness.zig");
const Value = @import("../Value.zig"); const Value = @import("../Value.zig");
const SpvModule = @import("../codegen/spirv/Module.zig"); const SpvModule = @import("../codegen/spirv/Module.zig");
const Section = @import("../codegen/spirv/Section.zig");
const spec = @import("../codegen/spirv/spec.zig"); const spec = @import("../codegen/spirv/spec.zig");
const IdResult = spec.IdResult; const IdResult = spec.IdResult;
const Word = spec.Word;
const BinaryModule = @import("SpirV/BinaryModule.zig");
base: link.File, base: link.File,
@ -163,6 +167,7 @@ pub fn updateExports(
.Vertex => spec.ExecutionModel.Vertex, .Vertex => spec.ExecutionModel.Vertex,
.Fragment => spec.ExecutionModel.Fragment, .Fragment => spec.ExecutionModel.Fragment,
.Kernel => spec.ExecutionModel.Kernel, .Kernel => spec.ExecutionModel.Kernel,
.C => return, // TODO: What to do here?
else => unreachable, else => unreachable,
}; };
const is_vulkan = target.os.tag == .vulkan; const is_vulkan = target.os.tag == .vulkan;
@ -197,8 +202,6 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node
@panic("Attempted to compile for architecture that was disabled by build configuration"); @panic("Attempted to compile for architecture that was disabled by build configuration");
} }
_ = arena; // Has the same lifetime as the call to Compilation.update.
const tracy = trace(@src()); const tracy = trace(@src());
defer tracy.end(); defer tracy.end();
@ -223,9 +226,9 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node
defer error_info.deinit(); defer error_info.deinit();
try error_info.appendSlice("zig_errors"); try error_info.appendSlice("zig_errors");
const module = self.base.comp.module.?; const mod = self.base.comp.module.?;
for (module.global_error_set.keys()) |name_nts| { for (mod.global_error_set.keys()) |name_nts| {
const name = module.intern_pool.stringToSlice(name_nts); const name = mod.intern_pool.stringToSlice(name_nts);
// Errors can contain pretty much any character - to encode them in a string we must escape // Errors can contain pretty much any character - to encode them in a string we must escape
// them somehow. Easiest here is to use some established scheme, one which also preseves the // them somehow. Easiest here is to use some established scheme, one which also preseves the
// name if it contains no strange characters is nice for debugging. URI encoding fits the bill. // name if it contains no strange characters is nice for debugging. URI encoding fits the bill.
@ -239,7 +242,29 @@ pub fn flushModule(self: *SpirV, arena: Allocator, prog_node: *std.Progress.Node
.extension = error_info.items, .extension = error_info.items,
}); });
try spv.flush(self.base.file.?, target); const module = try spv.finalize(arena, target);
errdefer arena.free(module);
const new_module = self.lowerInstanceGlobals(arena, module) catch |err| switch (err) {
error.OutOfMemory => return error.OutOfMemory,
else => |other| {
std.debug.print("error while lowering instance globals: {s}\n", .{@errorName(other)});
return error.FlushFailure;
},
};
defer arena.free(new_module);
try self.base.file.?.writeAll(std.mem.sliceAsBytes(new_module));
}
fn lowerInstanceGlobals(self: *SpirV, a: Allocator, module: []Word) ![]Word {
_ = self;
var parser = try BinaryModule.Parser.init(a);
defer parser.deinit();
const binary = try parser.parse(module);
const lower_invocation_globals = @import("SpirV/lower_invocation_globals.zig");
return try lower_invocation_globals.run(&parser, binary);
} }
fn writeCapabilities(spv: *SpvModule, target: std.Target) !void { fn writeCapabilities(spv: *SpvModule, target: std.Target) !void {

View File

@ -33,6 +33,11 @@ ext_inst_map: std.AutoHashMapUnmanaged(ResultId, InstructionSet),
/// of Op(Spec)Constant and OpSwitch. /// of Op(Spec)Constant and OpSwitch.
arith_type_width: std.AutoHashMapUnmanaged(ResultId, u16), arith_type_width: std.AutoHashMapUnmanaged(ResultId, u16),
/// The starting offsets of some sections
sections: struct {
functions: usize,
},
pub fn deinit(self: *BinaryModule, a: Allocator) void { pub fn deinit(self: *BinaryModule, a: Allocator) void {
self.ext_inst_map.deinit(a); self.ext_inst_map.deinit(a);
self.arith_type_width.deinit(a); self.arith_type_width.deinit(a);
@ -43,6 +48,10 @@ pub fn iterateInstructions(self: BinaryModule) Instruction.Iterator {
return Instruction.Iterator.init(self.instructions); return Instruction.Iterator.init(self.instructions);
} }
pub fn iterateInstructionsFrom(self: BinaryModule, offset: usize) Instruction.Iterator {
return Instruction.Iterator.init(self.instructions[offset..]);
}
/// Errors that can be raised when the module is not correct. /// Errors that can be raised when the module is not correct.
/// Note that the parser doesn't validate SPIR-V modules by a /// Note that the parser doesn't validate SPIR-V modules by a
/// long shot. It only yields errors that critically prevent /// long shot. It only yields errors that critically prevent
@ -107,97 +116,6 @@ pub const Instruction = struct {
operands: []const Word, operands: []const Word,
}; };
/// This struct is used to return information about
/// a module's functions - entry points, functions,
/// list of callees.
pub const FunctionInfo = struct {
/// Information that is gathered about a particular function.
pub const Fn = struct {
/// The word-offset of the first word (of the OpFunction instruction)
/// of this instruction.
begin_offset: usize,
/// The past-end offset of the end (including operands) of the last
/// instruction of the function.
end_offset: usize,
/// The index of the first callee in `callee_store`.
first_callee: usize,
/// The module offset of the OpTypeFunction instruction corresponding
/// to this function.
/// We use an offset so that we don't need to keep a separate map.
type_offset: usize,
};
/// Maps function result-id -> Function information structure.
functions: std.AutoArrayHashMapUnmanaged(ResultId, Fn),
/// List of entry points in this module. Contains OpFunction result-ids.
entry_points: []const ResultId,
/// For each function, a list of function result-ids that it calls.
callee_store: []const ResultId,
pub fn deinit(self: *FunctionInfo, a: Allocator) void {
self.functions.deinit(a);
a.free(self.entry_points);
a.free(self.callee_store);
self.* = undefined;
}
/// Fetch the list of callees per function. Guaranteed to contain only unique IDs.
pub fn callees(self: FunctionInfo, fn_id: ResultId) []const ResultId {
const fn_index = self.functions.getIndex(fn_id).?;
const values = self.functions.values();
const first_callee = values[fn_index].first_callee;
if (fn_index == values.len - 1) {
return self.callee_store[first_callee..];
} else {
const next_first_callee = values[fn_index + 1].first_callee;
return self.callee_store[first_callee..next_first_callee];
}
}
/// Returns a topological ordering of the functions: For each item
/// in the returned list of OpFunction result-ids, it is guaranteed that
/// the callees have a lower index. Note that SPIR-V does not support
/// any recursion, so this always works.
pub fn topologicalSort(self: FunctionInfo, a: Allocator) ![]const ResultId {
var sort = std.ArrayList(ResultId).init(a);
defer sort.deinit();
var seen = try std.DynamicBitSetUnmanaged.initEmpty(a, self.functions.count());
defer seen.deinit(a);
var stack = std.ArrayList(ResultId).init(a);
defer stack.deinit();
for (self.functions.keys()) |id| {
try self.topologicalSortStep(id, &sort, &seen);
}
return try sort.toOwnedSlice();
}
fn topologicalSortStep(
self: FunctionInfo,
id: ResultId,
sort: *std.ArrayList(ResultId),
seen: *std.DynamicBitSetUnmanaged,
) !void {
const fn_index = self.functions.getIndex(id) orelse {
log.err("function calls invalid callee-id {}", .{@intFromEnum(id)});
return error.InvalidId;
};
if (seen.isSet(fn_index)) {
return;
}
seen.set(fn_index);
for (self.callees(id)) |callee| {
try self.topologicalSortStep(callee, sort, seen);
}
try sort.append(id);
}
};
/// This parser contains information (acceleration tables) /// This parser contains information (acceleration tables)
/// that can be persisted across different modules. This is /// that can be persisted across different modules. This is
/// used to initialize the module, and is also used when /// used to initialize the module, and is also used when
@ -256,8 +174,11 @@ pub const Parser = struct {
.instructions = module[header_words..], .instructions = module[header_words..],
.ext_inst_map = .{}, .ext_inst_map = .{},
.arith_type_width = .{}, .arith_type_width = .{},
.sections = undefined,
}; };
var maybe_function_section: ?usize = null;
// First pass through the module to verify basic structure and // First pass through the module to verify basic structure and
// to gather some initial stuff for more detailed analysis. // to gather some initial stuff for more detailed analysis.
// We want to check some stuff that Instruction.Iterator is no good for, // We want to check some stuff that Instruction.Iterator is no good for,
@ -297,6 +218,9 @@ pub const Parser = struct {
if (entry.found_existing) return error.DuplicateId; if (entry.found_existing) return error.DuplicateId;
entry.value_ptr.* = std.math.cast(u16, operands[1]) orelse return error.InvalidOperands; entry.value_ptr.* = std.math.cast(u16, operands[1]) orelse return error.InvalidOperands;
}, },
.OpFunction => if (maybe_function_section == null) {
maybe_function_section = offset;
},
else => {}, else => {},
} }
@ -317,89 +241,11 @@ pub const Parser = struct {
} }
} }
return binary; binary.sections = .{
} .functions = maybe_function_section orelse binary.instructions.len,
pub fn parseFunctionInfo(self: *Parser, binary: BinaryModule) ParseError!FunctionInfo {
var entry_points = std.AutoArrayHashMap(ResultId, void).init(self.a);
defer entry_points.deinit();
var functions = std.AutoArrayHashMap(ResultId, FunctionInfo.Fn).init(self.a);
errdefer functions.deinit();
var fn_ty_decls = std.AutoHashMap(ResultId, usize).init(self.a);
defer fn_ty_decls.deinit();
var calls = std.AutoArrayHashMap(ResultId, void).init(self.a);
defer calls.deinit();
var callee_store = std.ArrayList(ResultId).init(self.a);
defer callee_store.deinit();
var maybe_current_function: ?ResultId = null;
var begin: usize = undefined;
var fn_ty_id: ResultId = undefined;
var it = binary.iterateInstructions();
while (it.next()) |inst| {
switch (inst.opcode) {
.OpEntryPoint => {
const entry = try entry_points.getOrPut(@enumFromInt(inst.operands[1]));
if (entry.found_existing) return error.DuplicateId;
},
.OpTypeFunction => {
const entry = try fn_ty_decls.getOrPut(@enumFromInt(inst.operands[0]));
if (entry.found_existing) return error.DuplicateId;
entry.value_ptr.* = inst.offset;
},
.OpFunction => {
maybe_current_function = @enumFromInt(inst.operands[1]);
begin = inst.offset;
fn_ty_id = @enumFromInt(inst.operands[3]);
},
.OpFunctionCall => {
const callee: ResultId = @enumFromInt(inst.operands[2]);
try calls.put(callee, {});
},
.OpFunctionEnd => {
const current_function = maybe_current_function orelse {
log.err("encountered OpFunctionEnd without corresponding OpFunction", .{});
return error.InvalidPhysicalFormat;
};
const entry = try functions.getOrPut(current_function);
if (entry.found_existing) return error.DuplicateId;
const first_callee = callee_store.items.len;
try callee_store.appendSlice(calls.keys());
const type_offset = fn_ty_decls.get(fn_ty_id) orelse {
log.err("Invalid OpFunction type", .{});
return error.InvalidId;
};
entry.value_ptr.* = .{
.begin_offset = begin,
.end_offset = it.offset, // Use past-end offset
.first_callee = first_callee,
.type_offset = type_offset,
};
maybe_current_function = null;
calls.clearRetainingCapacity();
},
else => {},
}
}
if (maybe_current_function != null) {
log.err("final OpFunction does not have an OpFunctionEnd", .{});
return error.InvalidPhysicalFormat;
}
return FunctionInfo{
.functions = functions.unmanaged,
.entry_points = try self.a.dupe(ResultId, entry_points.keys()),
.callee_store = try callee_store.toOwnedSlice(),
}; };
return binary;
} }
/// Parse offsets in the instruction that contain result-ids. /// Parse offsets in the instruction that contain result-ids.
@ -438,7 +284,7 @@ pub const Parser = struct {
if (offset + 1 >= inst.operands.len) return error.InvalidPhysicalFormat; if (offset + 1 >= inst.operands.len) return error.InvalidPhysicalFormat;
const set_id: ResultId = @enumFromInt(inst.operands[offset]); const set_id: ResultId = @enumFromInt(inst.operands[offset]);
const set = binary.ext_inst_map.get(set_id) orelse { const set = binary.ext_inst_map.get(set_id) orelse {
log.err("Invalid instruction set {}", .{@intFromEnum(set_id)}); log.err("invalid instruction set {}", .{@intFromEnum(set_id)});
return error.InvalidId; return error.InvalidId;
}; };
const ext_opcode = std.math.cast(u16, inst.operands[offset + 1]) orelse return error.InvalidPhysicalFormat; const ext_opcode = std.math.cast(u16, inst.operands[offset + 1]) orelse return error.InvalidPhysicalFormat;

View File

@ -0,0 +1,714 @@
const std = @import("std");
const Allocator = std.mem.Allocator;
const assert = std.debug.assert;
const log = std.log.scoped(.spirv_link);
const BinaryModule = @import("BinaryModule.zig");
const Section = @import("../../codegen/spirv/Section.zig");
const spec = @import("../../codegen/spirv/spec.zig");
const ResultId = spec.IdResult;
const Word = spec.Word;
/// This structure contains all the stuff that we need to parse from the module in
/// order to run this pass, as well as some functions to ease its use.
const ModuleInfo = struct {
/// Information about a particular function.
const Fn = struct {
/// The index of the first callee in `callee_store`.
first_callee: usize,
/// The return type id of this function
return_type: ResultId,
/// The parameter types of this function
param_types: []const ResultId,
/// The set of (result-id's of) invocation globals that are accessed
/// in this function, or after resolution, that are accessed in this
/// function or any of it's callees.
invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, void),
};
/// Information about a particular invocation global
const InvocationGlobal = struct {
/// The list of invocation globals that this invocation global
/// depends on.
dependencies: std.AutoArrayHashMapUnmanaged(ResultId, void),
/// The invocation global's type
ty: ResultId,
/// Initializer function. May be `none`.
/// Note that if the initializer is `none`, then `dependencies` is empty.
initializer: ResultId,
};
/// Maps function result-id -> Fn information structure.
functions: std.AutoArrayHashMapUnmanaged(ResultId, Fn),
/// Set of OpFunction result-ids in this module.
entry_points: std.AutoArrayHashMapUnmanaged(ResultId, void),
/// For each function, a list of function result-ids that it calls.
callee_store: []const ResultId,
/// Maps each invocation global result-id to a type-id.
invocation_globals: std.AutoArrayHashMapUnmanaged(ResultId, InvocationGlobal),
/// Fetch the list of callees per function. Guaranteed to contain only unique IDs.
fn callees(self: ModuleInfo, fn_id: ResultId) []const ResultId {
const fn_index = self.functions.getIndex(fn_id).?;
const values = self.functions.values();
const first_callee = values[fn_index].first_callee;
if (fn_index == values.len - 1) {
return self.callee_store[first_callee..];
} else {
const next_first_callee = values[fn_index + 1].first_callee;
return self.callee_store[first_callee..next_first_callee];
}
}
/// Extract most of the required information from the binary. The remaining info is
/// constructed by `resolve()`.
fn parse(
arena: Allocator,
parser: *BinaryModule.Parser,
binary: BinaryModule,
) BinaryModule.ParseError!ModuleInfo {
var entry_points = std.AutoArrayHashMap(ResultId, void).init(arena);
var functions = std.AutoArrayHashMap(ResultId, Fn).init(arena);
var fn_types = std.AutoHashMap(ResultId, struct {
return_type: ResultId,
param_types: []const ResultId,
}).init(arena);
var calls = std.AutoArrayHashMap(ResultId, void).init(arena);
var callee_store = std.ArrayList(ResultId).init(arena);
var function_invocation_globals = std.AutoArrayHashMap(ResultId, void).init(arena);
var result_id_offsets = std.ArrayList(u16).init(arena);
var invocation_globals = std.AutoArrayHashMap(ResultId, InvocationGlobal).init(arena);
var maybe_current_function: ?ResultId = null;
var fn_ty_id: ResultId = undefined;
var it = binary.iterateInstructions();
while (it.next()) |inst| {
result_id_offsets.items.len = 0;
try parser.parseInstructionResultIds(binary, inst, &result_id_offsets);
switch (inst.opcode) {
.OpEntryPoint => {
const entry_point: ResultId = @enumFromInt(inst.operands[1]);
const entry = try entry_points.getOrPut(entry_point);
if (entry.found_existing) {
log.err("Entry point type {} has duplicate definition", .{entry_point});
return error.DuplicateId;
}
},
.OpTypeFunction => {
const fn_type: ResultId = @enumFromInt(inst.operands[0]);
const return_type: ResultId = @enumFromInt(inst.operands[1]);
const param_types: []const ResultId = @ptrCast(inst.operands[2..]);
const entry = try fn_types.getOrPut(fn_type);
if (entry.found_existing) {
log.err("Function type {} has duplicate definition", .{fn_type});
return error.DuplicateId;
}
entry.value_ptr.* = .{
.return_type = return_type,
.param_types = param_types,
};
},
.OpExtInst => {
// Note: format and set are already verified by parseInstructionResultIds().
const global_type: ResultId = @enumFromInt(inst.operands[0]);
const result_id: ResultId = @enumFromInt(inst.operands[1]);
const set_id: ResultId = @enumFromInt(inst.operands[2]);
const set_inst = inst.operands[3];
const set = binary.ext_inst_map.get(set_id).?;
if (set == .zig and set_inst == 0) {
const initializer: ResultId = if (inst.operands.len >= 5)
@enumFromInt(inst.operands[4])
else
.none;
try invocation_globals.put(result_id, .{
.dependencies = .{},
.ty = global_type,
.initializer = initializer,
});
}
},
.OpFunction => {
if (maybe_current_function) |current_function| {
log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
return error.InvalidPhysicalFormat;
}
maybe_current_function = @enumFromInt(inst.operands[1]);
fn_ty_id = @enumFromInt(inst.operands[3]);
function_invocation_globals.clearRetainingCapacity();
},
.OpFunctionCall => {
const callee: ResultId = @enumFromInt(inst.operands[2]);
try calls.put(callee, {});
},
.OpFunctionEnd => {
const current_function = maybe_current_function orelse {
log.err("encountered OpFunctionEnd without corresponding OpFunction", .{});
return error.InvalidPhysicalFormat;
};
const entry = try functions.getOrPut(current_function);
if (entry.found_existing) {
log.err("Function {} has duplicate definition", .{current_function});
return error.DuplicateId;
}
const first_callee = callee_store.items.len;
try callee_store.appendSlice(calls.keys());
const fn_type = fn_types.get(fn_ty_id) orelse {
log.err("Function {} has invalid OpFunction type", .{current_function});
return error.InvalidId;
};
entry.value_ptr.* = .{
.first_callee = first_callee,
.return_type = fn_type.return_type,
.param_types = fn_type.param_types,
.invocation_globals = try function_invocation_globals.unmanaged.clone(arena),
};
maybe_current_function = null;
calls.clearRetainingCapacity();
},
else => {},
}
for (result_id_offsets.items) |off| {
const result_id: ResultId = @enumFromInt(inst.operands[off]);
if (invocation_globals.contains(result_id)) {
try function_invocation_globals.put(result_id, {});
}
}
}
if (maybe_current_function) |current_function| {
log.err("OpFunction {} does not have an OpFunctionEnd", .{current_function});
return error.InvalidPhysicalFormat;
}
return ModuleInfo{
.functions = functions.unmanaged,
.entry_points = entry_points.unmanaged,
.callee_store = callee_store.items,
.invocation_globals = invocation_globals.unmanaged,
};
}
/// Derive the remaining info from the structures filled in by parsing.
fn resolve(self: *ModuleInfo, arena: Allocator) !void {
try self.resolveInvocationGlobalUsage(arena);
try self.resolveInvocationGlobalDependencies(arena);
}
/// For each function, extend the list of `invocation_globals` with the
/// invocation globals that ALL of its dependencies use.
fn resolveInvocationGlobalUsage(self: *ModuleInfo, arena: Allocator) !void {
var seen = try std.DynamicBitSetUnmanaged.initEmpty(arena, self.functions.count());
for (self.functions.keys()) |id| {
try self.resolveInvocationGlobalUsageStep(arena, id, &seen);
}
}
fn resolveInvocationGlobalUsageStep(
self: *ModuleInfo,
arena: Allocator,
id: ResultId,
seen: *std.DynamicBitSetUnmanaged,
) !void {
const index = self.functions.getIndex(id) orelse {
log.err("function calls invalid function {}", .{id});
return error.InvalidId;
};
if (seen.isSet(index)) {
return;
}
seen.set(index);
const info = &self.functions.values()[index];
for (self.callees(id)) |callee| {
try self.resolveInvocationGlobalUsageStep(arena, callee, seen);
const callee_info = self.functions.get(callee).?;
for (callee_info.invocation_globals.keys()) |global| {
try info.invocation_globals.put(arena, global, {});
}
}
}
/// For each invocation global, populate and fully resolve the `dependencies` set.
/// This requires `resolveInvocationGlobalUsage()` to be already done.
fn resolveInvocationGlobalDependencies(
self: *ModuleInfo,
arena: Allocator,
) !void {
var seen = try std.DynamicBitSetUnmanaged.initEmpty(arena, self.invocation_globals.count());
for (self.invocation_globals.keys()) |id| {
try self.resolveInvocationGlobalDependenciesStep(arena, id, &seen);
}
}
fn resolveInvocationGlobalDependenciesStep(
self: *ModuleInfo,
arena: Allocator,
id: ResultId,
seen: *std.DynamicBitSetUnmanaged,
) !void {
const index = self.invocation_globals.getIndex(id) orelse {
log.err("invalid invocation global {}", .{id});
return error.InvalidId;
};
if (seen.isSet(index)) {
return;
}
seen.set(index);
const info = &self.invocation_globals.values()[index];
if (info.initializer == .none) {
return;
}
const initializer = self.functions.get(info.initializer) orelse {
log.err("invocation global {} has invalid initializer {}", .{ id, info.initializer });
return error.InvalidId;
};
for (initializer.invocation_globals.keys()) |dependency| {
if (dependency == id) {
// The set of invocation global dependencies includes the dependency itself,
// so we need to skip that case.
continue;
}
try info.dependencies.put(arena, dependency, {});
try self.resolveInvocationGlobalDependenciesStep(arena, dependency, seen);
const dep_info = self.invocation_globals.getPtr(dependency).?;
for (dep_info.dependencies.keys()) |global| {
try info.dependencies.put(arena, global, {});
}
}
}
};
const ModuleBuilder = struct {
const FunctionType = struct {
return_type: ResultId,
param_types: []const ResultId,
const Context = struct {
pub fn hash(_: @This(), ty: FunctionType) u32 {
var hasher = std.hash.Wyhash.init(0);
hasher.update(std.mem.asBytes(&ty.return_type));
hasher.update(std.mem.sliceAsBytes(ty.param_types));
return @truncate(hasher.final());
}
pub fn eql(_: @This(), a: FunctionType, b: FunctionType, _: usize) bool {
if (a.return_type != b.return_type) return false;
return std.mem.eql(ResultId, a.param_types, b.param_types);
}
};
};
const FunctionNewInfo = struct {
/// This is here just so that we don't need to allocate the new
/// param_types multiple times.
new_function_type: ResultId,
/// The first ID of the parameters for the invocation globals.
/// Each global is allocate here according to the index in
/// `ModuleInfo.Fn.invocation_globals`.
global_id_base: u32,
fn invocationGlobalId(self: FunctionNewInfo, index: usize) ResultId {
return @enumFromInt(self.global_id_base + @as(u32, @intCast(index)));
}
};
arena: Allocator,
section: Section,
/// The ID bound of the new module.
id_bound: u32,
/// The first ID of the new entry points. Entry points are allocated from
/// here according to their index in `info.entry_points`.
entry_point_new_id_base: u32,
/// A set of all function types in the new program. SPIR-V mandates that these are unique,
/// and until a general type deduplication pass is programmed, we just handle it here via this.
function_types: std.ArrayHashMapUnmanaged(FunctionType, ResultId, FunctionType.Context, true) = .{},
/// Maps functions to new information required for creating the module
function_new_info: std.AutoArrayHashMapUnmanaged(ResultId, FunctionNewInfo) = .{},
fn init(arena: Allocator, binary: BinaryModule, info: ModuleInfo) !ModuleBuilder {
var section = Section{};
try section.instructions.appendSlice(arena, &.{
spec.magic_number,
@bitCast(binary.version),
spec.zig_generator_id,
0, // Filled in in finalize()
0, // Schema (reserved)
});
var self = ModuleBuilder{
.arena = arena,
.section = section,
.id_bound = binary.id_bound,
.entry_point_new_id_base = undefined,
};
self.entry_point_new_id_base = @intFromEnum(self.allocIds(@intCast(info.entry_points.count())));
return self;
}
fn allocId(self: *ModuleBuilder) ResultId {
return self.allocIds(1);
}
fn allocIds(self: *ModuleBuilder, n: u32) ResultId {
defer self.id_bound += n;
return @enumFromInt(self.id_bound);
}
fn finalize(self: *ModuleBuilder, a: Allocator) ![]Word {
self.section.instructions.items[3] = self.id_bound;
return try a.dupe(Word, self.section.instructions.items);
}
/// Process everything from `binary` up to the first function and emit it into the builder.
fn processPreamble(self: *ModuleBuilder, binary: BinaryModule, info: ModuleInfo) !void {
var it = binary.iterateInstructions();
while (it.next()) |inst| {
switch (inst.opcode) {
// TODO: We should remove this instruction using something that eliminates unreferenced instructions.
// For now, this is the only place where the .zig instruction set is being referenced, so its safe
// to remove it here.
.OpExtInstImport => {
const set_id: ResultId = @enumFromInt(inst.operands[0]);
const set = binary.ext_inst_map.get(set_id).?;
if (set == .zig) {
continue;
}
},
.OpExtInst => {
const set_id: ResultId = @enumFromInt(inst.operands[2]);
const set_inst = inst.operands[3];
const set = binary.ext_inst_map.get(set_id).?;
if (set == .zig and set_inst == 0) {
continue;
}
},
.OpEntryPoint => {
const original_id: ResultId = @enumFromInt(inst.operands[1]);
const new_id_index = info.entry_points.getIndex(original_id).?;
const new_id: ResultId = @enumFromInt(self.entry_point_new_id_base + new_id_index);
try self.section.emitRaw(self.arena, .OpEntryPoint, inst.operands.len);
self.section.writeWord(inst.operands[0]);
self.section.writeOperand(ResultId, new_id);
self.section.writeWords(inst.operands[2..]);
continue;
},
.OpTypeFunction => {
// Re-emitted in `emitFunctionTypes()`. We can do this because
// OpTypeFunction's may not currently be used anywhere that is not
// directly with an OpFunction. For now we igore Intels function
// pointers extension, that is not a problem with a generalized
// pass anyway.
continue;
},
.OpFunction => break,
else => {},
}
try self.section.emitRawInstruction(self.arena, inst.opcode, inst.operands);
}
}
/// Derive new information required for further emitting this module,
fn deriveNewFnInfo(self: *ModuleBuilder, info: ModuleInfo) !void {
for (info.functions.keys(), info.functions.values()) |func, fn_info| {
const invocation_global_count = fn_info.invocation_globals.count();
const new_param_types = try self.arena.alloc(ResultId, fn_info.param_types.len + invocation_global_count);
for (fn_info.invocation_globals.keys(), 0..) |global, i| {
new_param_types[i] = info.invocation_globals.get(global).?.ty;
}
@memcpy(new_param_types[invocation_global_count..], fn_info.param_types);
const new_type = try self.internFunctionType(fn_info.return_type, new_param_types);
try self.function_new_info.put(self.arena, func, .{
.new_function_type = new_type,
.global_id_base = @intFromEnum(self.allocIds(@intCast(invocation_global_count))),
});
}
}
/// Emit the new function types, which include the parameters for the invocation globals.
/// Currently, this function re-emits ALL function types to ensure that there are
/// no duplicates in the final program.
/// TODO: The above should be resolved by a generalized deduplication pass, and then
/// we only need to emit the new function pointers type here.
fn emitFunctionTypes(self: *ModuleBuilder, info: ModuleInfo) !void {
// TODO: Handle decorators. Function types usually don't have those
// though, but stuff like OpName could be a possibility.
// Entry points retain their old function type, so make sure to emit
// those in the `function_types` set.
for (info.entry_points.keys()) |func| {
const fn_info = info.functions.get(func).?;
_ = try self.internFunctionType(fn_info.return_type, fn_info.param_types);
}
for (self.function_types.keys(), self.function_types.values()) |fn_type, result_id| {
try self.section.emit(self.arena, .OpTypeFunction, .{
.id_result = result_id,
.return_type = fn_type.return_type,
.id_ref_2 = fn_type.param_types,
});
}
}
fn internFunctionType(self: *ModuleBuilder, return_type: ResultId, param_types: []const ResultId) !ResultId {
const entry = try self.function_types.getOrPut(self.arena, .{
.return_type = return_type,
.param_types = param_types,
});
if (!entry.found_existing) {
const new_id = self.allocId();
entry.value_ptr.* = new_id;
}
return entry.value_ptr.*;
}
/// Rewrite the modules' functions and emit them with the new parameter types.
fn rewriteFunctions(
self: *ModuleBuilder,
parser: *BinaryModule.Parser,
binary: BinaryModule,
info: ModuleInfo,
) !void {
var result_id_offsets = std.ArrayList(u16).init(self.arena);
var operands = std.ArrayList(u32).init(self.arena);
var maybe_current_function: ?ResultId = null;
var it = binary.iterateInstructionsFrom(binary.sections.functions);
while (it.next()) |inst| {
result_id_offsets.items.len = 0;
try parser.parseInstructionResultIds(binary, inst, &result_id_offsets);
operands.items.len = 0;
try operands.appendSlice(inst.operands);
// Replace the result-ids with the global's new result-id if required.
for (result_id_offsets.items) |off| {
const result_id: ResultId = @enumFromInt(operands.items[off]);
if (info.invocation_globals.contains(result_id)) {
const func = maybe_current_function.?;
const new_info = self.function_new_info.get(func).?;
const fn_info = info.functions.get(func).?;
const index = fn_info.invocation_globals.getIndex(result_id).?;
operands.items[off] = @intFromEnum(new_info.invocationGlobalId(index));
}
}
switch (inst.opcode) {
.OpFunction => {
// Re-declare the function with the new parameters.
const func: ResultId = @enumFromInt(operands.items[1]);
const fn_info = info.functions.get(func).?;
const new_info = self.function_new_info.get(func).?;
try self.section.emitRaw(self.arena, .OpFunction, 4);
self.section.writeOperand(ResultId, fn_info.return_type);
self.section.writeOperand(ResultId, func);
self.section.writeWord(operands.items[2]);
self.section.writeOperand(ResultId, new_info.new_function_type);
// Emit the OpFunctionParameters for the invocation globals. The functions
// actual parameters are emitted unchanged from their original form, so
// we don't need to handle those here.
for (fn_info.invocation_globals.keys(), 0..) |global, index| {
const ty = info.invocation_globals.get(global).?.ty;
const id = new_info.invocationGlobalId(index);
try self.section.emit(self.arena, .OpFunctionParameter, .{
.id_result_type = ty,
.id_result = id,
});
}
maybe_current_function = func;
},
.OpFunctionCall => {
// Add the required invocation globals to the function's new parameter list.
const caller = maybe_current_function.?;
const callee: ResultId = @enumFromInt(operands.items[2]);
const caller_info = info.functions.get(caller).?;
const callee_info = info.functions.get(callee).?;
const caller_new_info = self.function_new_info.get(caller).?;
const total_params = callee_info.invocation_globals.count() + callee_info.param_types.len;
try self.section.emitRaw(self.arena, .OpFunctionCall, 3 + total_params);
self.section.writeWord(operands.items[0]); // Copy result type-id
self.section.writeWord(operands.items[1]); // Copy result-id
self.section.writeOperand(ResultId, callee);
// Add the new arguments
for (callee_info.invocation_globals.keys()) |global| {
const caller_global_index = caller_info.invocation_globals.getIndex(global).?;
const id = caller_new_info.invocationGlobalId(caller_global_index);
self.section.writeOperand(ResultId, id);
}
// Add the original arguments
self.section.writeWords(operands.items[3..]);
},
else => {
try self.section.emitRawInstruction(self.arena, inst.opcode, operands.items);
},
}
}
}
fn emitNewEntryPoints(self: *ModuleBuilder, info: ModuleInfo) !void {
var all_function_invocation_globals = std.AutoArrayHashMap(ResultId, void).init(self.arena);
for (info.entry_points.keys(), 0..) |func, entry_point_index| {
const fn_info = info.functions.get(func).?;
const ep_id: ResultId = @enumFromInt(self.entry_point_new_id_base + @as(u32, @intCast(entry_point_index)));
const fn_type = self.function_types.get(.{
.return_type = fn_info.return_type,
.param_types = fn_info.param_types,
}).?;
try self.section.emit(self.arena, .OpFunction, .{
.id_result_type = fn_info.return_type,
.id_result = ep_id,
.function_control = .{}, // TODO: Copy the attributes from the original function maybe?
.function_type = fn_type,
});
// Emit OpFunctionParameter instructions for the original kernel's parameters.
const params_id_base: u32 = @intFromEnum(self.allocIds(@intCast(fn_info.param_types.len)));
for (fn_info.param_types, 0..) |param_type, i| {
const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(i)));
try self.section.emit(self.arena, .OpFunctionParameter, .{
.id_result_type = param_type,
.id_result = id,
});
}
try self.section.emit(self.arena, .OpLabel, .{
.id_result = self.allocId(),
});
// Besides the IDs of the main kernel, we also need the
// dependencies of the globals.
// Just quickly construct that set here.
all_function_invocation_globals.clearRetainingCapacity();
for (fn_info.invocation_globals.keys()) |global| {
try all_function_invocation_globals.put(global, {});
const global_info = info.invocation_globals.get(global).?;
for (global_info.dependencies.keys()) |dependency| {
try all_function_invocation_globals.put(dependency, {});
}
}
// Declare the IDs of the invocation globals.
const global_id_base: u32 = @intFromEnum(self.allocIds(@intCast(all_function_invocation_globals.count())));
for (all_function_invocation_globals.keys(), 0..) |global, i| {
const global_info = info.invocation_globals.get(global).?;
const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(i)));
try self.section.emit(self.arena, .OpVariable, .{
.id_result_type = global_info.ty,
.id_result = id,
.storage_class = .Function,
.initializer = null,
});
}
// Call initializers for invocation globals that need it
for (all_function_invocation_globals.keys()) |global| {
const global_info = info.invocation_globals.get(global).?;
if (global_info.initializer == .none) continue;
const initializer_info = info.functions.get(global_info.initializer).?;
assert(initializer_info.param_types.len == 0);
try self.callWithGlobalsAndLinearParams(
all_function_invocation_globals,
global_info.initializer,
initializer_info,
global_id_base,
undefined,
);
}
// Call the main kernel entry
try self.callWithGlobalsAndLinearParams(
all_function_invocation_globals,
func,
fn_info,
global_id_base,
params_id_base,
);
try self.section.emit(self.arena, .OpReturn, {});
try self.section.emit(self.arena, .OpFunctionEnd, {});
}
}
fn callWithGlobalsAndLinearParams(
self: *ModuleBuilder,
all_globals: std.AutoArrayHashMap(ResultId, void),
func: ResultId,
callee_info: ModuleInfo.Fn,
global_id_base: u32,
params_id_base: u32,
) !void {
const total_arguments = callee_info.invocation_globals.count() + callee_info.param_types.len;
try self.section.emitRaw(self.arena, .OpFunctionCall, 3 + total_arguments);
self.section.writeOperand(ResultId, callee_info.return_type);
self.section.writeOperand(ResultId, self.allocId());
self.section.writeOperand(ResultId, func);
// Add the invocation globals
for (callee_info.invocation_globals.keys()) |global| {
const index = all_globals.getIndex(global).?;
const id: ResultId = @enumFromInt(global_id_base + @as(u32, @intCast(index)));
self.section.writeOperand(ResultId, id);
}
// Add the arguments
for (0..callee_info.param_types.len) |index| {
const id: ResultId = @enumFromInt(params_id_base + @as(u32, @intCast(index)));
self.section.writeOperand(ResultId, id);
}
}
};
pub fn run(parser: *BinaryModule.Parser, binary: BinaryModule) ![]Word {
var arena = std.heap.ArenaAllocator.init(parser.a);
defer arena.deinit();
const a = arena.allocator();
var info = try ModuleInfo.parse(a, parser, binary);
try info.resolve(a);
var builder = try ModuleBuilder.init(a, binary, info);
try builder.deriveNewFnInfo(info);
try builder.processPreamble(binary, info);
try builder.emitFunctionTypes(info);
try builder.rewriteFunctions(parser, binary, info);
try builder.emitNewEntryPoints(info);
return builder.finalize(parser.a);
}

View File

@ -757,6 +757,7 @@ test "extern variable with non-pointer opaque type" {
if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; // TODO
@export(var_to_export, .{ .name = "opaque_extern_var" }); @export(var_to_export, .{ .name = "opaque_extern_var" });
try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42); try expect(@as(*align(1) u32, @ptrCast(&opaque_extern_var)).* == 42);

View File

@ -42,6 +42,26 @@ const StringPairContext = struct {
const OperandKindMap = std.ArrayHashMap(StringPair, OperandKind, StringPairContext, true); const OperandKindMap = std.ArrayHashMap(StringPair, OperandKind, StringPairContext, true);
/// Khronos made it so that these names are not defined explicitly, so
/// we need to hardcode it (like they did).
/// See https://github.com/KhronosGroup/SPIRV-Registry/
const set_names = std.ComptimeStringMap([]const u8, .{
.{ "opencl.std.100", "OpenCL.std" },
.{ "glsl.std.450", "GLSL.std.450" },
.{ "opencl.debuginfo.100", "OpenCL.DebugInfo.100" },
.{ "spv-amd-shader-ballot", "SPV_AMD_shader_ballot" },
.{ "nonsemantic.shader.debuginfo.100", "NonSemantic.Shader.DebugInfo.100" },
.{ "nonsemantic.vkspreflection", "NonSemantic.VkspReflection" },
.{ "nonsemantic.clspvreflection", "NonSemantic.ClspvReflection.6" }, // This version needs to be handled manually
.{ "spv-amd-gcn-shader", "SPV_AMD_gcn_shader" },
.{ "spv-amd-shader-trinary-minmax", "SPV_AMD_shader_trinary_minmax" },
.{ "debuginfo", "DebugInfo" },
.{ "nonsemantic.debugprintf", "NonSemantic.DebugPrintf" },
.{ "spv-amd-shader-explicit-vertex-parameter", "SPV_AMD_shader_explicit_vertex_parameter" },
.{ "nonsemantic.debugbreak", "NonSemantic.DebugBreak" },
.{ "zig", "zig" },
});
pub fn main() !void { pub fn main() !void {
var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator); var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
defer arena.deinit(); defer arena.deinit();
@ -88,7 +108,7 @@ fn readExtRegistry(exts: *std.ArrayList(Extension), a: Allocator, dir: std.fs.Di
std.sort.block(Instruction, spec.instructions, CmpInst{}, CmpInst.lt); std.sort.block(Instruction, spec.instructions, CmpInst{}, CmpInst.lt);
try exts.append(.{ .name = try a.dupe(u8, name), .spec = spec }); try exts.append(.{ .name = set_names.get(name).?, .spec = spec });
} }
fn readRegistry(comptime RegistryType: type, a: Allocator, dir: std.fs.Dir, path: []const u8) !RegistryType { fn readRegistry(comptime RegistryType: type, a: Allocator, dir: std.fs.Dir, path: []const u8) !RegistryType {
@ -150,6 +170,8 @@ fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []c
try writer.writeAll( try writer.writeAll(
\\//! This file is auto-generated by tools/gen_spirv_spec.zig. \\//! This file is auto-generated by tools/gen_spirv_spec.zig.
\\ \\
\\const std = @import("std");
\\
\\pub const Version = packed struct(Word) { \\pub const Version = packed struct(Word) {
\\ padding: u8 = 0, \\ padding: u8 = 0,
\\ minor: u8, \\ minor: u8,
@ -163,8 +185,20 @@ fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []c
\\ \\
\\pub const Word = u32; \\pub const Word = u32;
\\pub const IdResult = enum(Word) { \\pub const IdResult = enum(Word) {
\\ none, \\ none,
\\ _, \\ _,
\\
\\ pub fn format(
\\ self: IdResult,
\\ comptime _: []const u8,
\\ _: std.fmt.FormatOptions,
\\ writer: anytype,
\\ ) @TypeOf(writer).Error!void {
\\ switch (self) {
\\ .none => try writer.writeAll("(none)"),
\\ else => try writer.print("%{}", .{@intFromEnum(self)}),
\\ }
\\ }
\\}; \\};
\\pub const IdResultType = IdResult; \\pub const IdResultType = IdResult;
\\pub const IdRef = IdResult; \\pub const IdRef = IdResult;
@ -220,6 +254,7 @@ fn render(writer: anytype, a: Allocator, registry: CoreRegistry, extensions: []c
\\ operands: []const Operand, \\ operands: []const Operand,
\\}; \\};
\\ \\
\\pub const zig_generator_id: Word = 41;
\\ \\
); );