Commit fcb422585c
Changed files (3)
src
codegen
src/codegen/spirv/Module.zig
@@ -235,6 +235,10 @@ pub fn resolveId(self: *Module, key: TypeConstantCache.Key) !IdResult {
return self.resultId(try self.resolve(key));
}
+pub fn resolveString(self: *Module, str: []const u8) !TypeConstantCache.String {
+ return try self.tc_cache.addString(self, str);
+}
+
fn orderGlobalsInto(
self: *Module,
decl_index: Decl.Index,
@@ -769,6 +773,21 @@ pub fn simpleStructType(self: *Module, members: []const Type.Payload.Struct.Memb
return try self.resolveType(Type.initPayload(&payload.base));
}
+pub fn arrayType2(self: *Module, len: u32, elem_ty_ref: TypeConstantCache.Ref) !TypeConstantCache.Ref {
+ const len_ty_ref = try self.resolve(.{ .int_type = .{
+ .signedness = .unsigned,
+ .bits = 32,
+ } });
+ const len_ref = try self.resolve(.{ .int = .{
+ .ty = len_ty_ref,
+ .value = .{ .uint64 = len },
+ } });
+ return try self.resolve(.{ .array_type = .{
+ .element_type = elem_ty_ref,
+ .length = len_ref,
+ } });
+}
+
pub fn arrayType(self: *Module, len: u32, ty: Type.Ref) !Type.Ref {
const payload = try self.arena.create(Type.Payload.Array);
payload.* = .{
src/codegen/spirv/TypeConstantCache.zig
@@ -263,7 +263,7 @@ pub const Key = union(enum) {
pub const StructType = struct {
// TODO: Decorations.
/// The name of the structure. Can be `.none`.
- name: String,
+ name: String = .none,
/// The type of each member.
member_types: []const Ref,
/// Name for each member. May be omitted.
@@ -922,14 +922,14 @@ pub const String = enum(u32) {
self: *const Self,
pub fn eql(ctx: @This(), a: []const u8, _: void, b_index: usize) bool {
- const offset = ctx.self.string_map.values()[b_index];
+ const offset = ctx.self.strings.values()[b_index];
const b = std.mem.sliceTo(ctx.self.string_bytes.items[offset..], 0);
return std.mem.eql(u8, a, b);
}
pub fn hash(ctx: @This(), a: []const u8) u32 {
_ = ctx;
- const hasher = std.hash.Wyhash.init(0);
+ var hasher = std.hash.Wyhash.init(0);
hasher.update(a);
return @truncate(u32, hasher.final());
}
@@ -937,16 +937,16 @@ pub const String = enum(u32) {
};
/// Add a string to the cache. Must not contain any 0 values.
-pub fn addString(self: *Self, spv: *Module, str: []const u8) String {
+pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {
assert(std.mem.indexOfScalar(u8, str, 0) == null);
const adapter = String.Adapter{ .self = self };
const entry = try self.strings.getOrPutAdapted(spv.gpa, str, adapter);
if (!entry.found_existing) {
const offset = self.string_bytes.items.len;
- try self.string_bytes.ensureUnusedCapacity(1 + str.len);
- self.string_bytes.appendAssumeCapacity(str);
- self.string_bytes.append(0);
- entry.value_ptr.* = offset;
+ try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);
+ self.string_bytes.appendSliceAssumeCapacity(str);
+ self.string_bytes.appendAssumeCapacity(0);
+ entry.value_ptr.* = @intCast(u32, offset);
}
return @intToEnum(String, entry.index);
src/codegen/spirv.zig
@@ -22,7 +22,8 @@ const IdResultType = spec.IdResultType;
const StorageClass = spec.StorageClass;
const SpvModule = @import("spirv/Module.zig");
-const SpvRef = SpvModule.TypeConstantCache.Ref;
+const SpvCacheRef = SpvModule.TypeConstantCache.Ref;
+const SpvCacheString = SpvModule.TypeConstantCache.String;
const SpvSection = @import("spirv/Section.zig");
const SpvType = @import("spirv/type.zig").Type;
@@ -1160,7 +1161,7 @@ pub const DeclGen = struct {
return try self.spv.resolveType(try SpvType.int(self.spv.arena, signedness, backing_bits));
}
- fn intType2(self: *DeclGen, signedness: std.builtin.Signedness, bits: u16) !SpvRef {
+ fn intType2(self: *DeclGen, signedness: std.builtin.Signedness, bits: u16) !SpvCacheRef {
const backing_bits = self.backingIntBits(bits) orelse {
// TODO: Integers too big for any native type are represented as "composite integers":
// An array of largestSupportedIntBits.
@@ -1177,7 +1178,7 @@ pub const DeclGen = struct {
return try self.intType(.unsigned, self.getTarget().ptrBitWidth());
}
- fn sizeType2(self: *DeclGen) !SpvRef {
+ fn sizeType2(self: *DeclGen) !SpvCacheRef {
return try self.intType2(.unsigned, self.getTarget().ptrBitWidth());
}
@@ -1256,7 +1257,91 @@ pub const DeclGen = struct {
return try self.spv.simpleStructType(members.slice());
}
- fn resolveType2(self: *DeclGen, ty: Type, repr: Repr) !SpvRef {
+ /// Generate a union type, optionally with a known field. If the tag alignment is greater
+ /// than that of the payload, a regular union (non-packed, with both tag and payload), will
+ /// be generated as follows:
+ /// If the active field is known:
+ /// struct {
+ /// tag: TagType,
+ /// payload: ActivePayloadType,
+ /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
+ /// padding: [padding_size]u8,
+ /// }
+ /// If the payload alignment is greater than that of the tag:
+ /// struct {
+ /// payload: ActivePayloadType,
+ /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
+ /// tag: TagType,
+ /// padding: [padding_size]u8,
+ /// }
+ /// If the active payload is unknown, it will default back to the most aligned field. This is
+ /// to make sure that the overal struct has the correct alignment in spir-v.
+ /// If any of the fields' size is 0, it will be omitted.
+ /// NOTE: When the active field is set to something other than the most aligned field, the
+ /// resulting struct will be *underaligned*.
+ fn resolveUnionType2(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !SpvCacheRef {
+ const target = self.getTarget();
+ const layout = ty.unionGetLayout(target);
+ const union_ty = ty.cast(Type.Payload.Union).?.data;
+
+ if (union_ty.layout == .Packed) {
+ return self.todo("packed union types", .{});
+ }
+
+ if (layout.payload_size == 0) {
+ // No payload, so represent this as just the tag type.
+ return try self.resolveType2(union_ty.tag_ty, .indirect);
+ }
+
+ var member_types = std.BoundedArray(SpvCacheRef, 4){};
+ var member_names = std.BoundedArray(SpvCacheString, 4){};
+
+ const has_tag = layout.tag_size != 0;
+ const tag_first = layout.tag_align >= layout.payload_align;
+ const u8_ty_ref = try self.intType2(.unsigned, 8); // TODO: What if Int8Type is not enabled?
+
+ if (has_tag and tag_first) {
+ const tag_ty_ref = try self.resolveType2(union_ty.tag_ty, .indirect);
+ member_types.appendAssumeCapacity(tag_ty_ref);
+ member_names.appendAssumeCapacity(try self.spv.resolveString("tag"));
+ }
+
+ const active_field = maybe_active_field orelse layout.most_aligned_field;
+ const active_field_ty = union_ty.fields.values()[active_field].ty;
+
+ const active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime()) blk: {
+ const active_payload_ty_ref = try self.resolveType2(active_field_ty, .indirect);
+ member_types.appendAssumeCapacity(active_payload_ty_ref);
+ member_names.appendAssumeCapacity(try self.spv.resolveString("payload"));
+ break :blk active_field_ty.abiSize(target);
+ } else 0;
+
+ const payload_padding_len = layout.payload_size - active_field_size;
+ if (payload_padding_len != 0) {
+ const payload_padding_ty_ref = try self.spv.arrayType2(@intCast(u32, payload_padding_len), u8_ty_ref);
+ member_types.appendAssumeCapacity(payload_padding_ty_ref);
+ member_names.appendAssumeCapacity(try self.spv.resolveString("payload_padding"));
+ }
+
+ if (has_tag and !tag_first) {
+ const tag_ty_ref = try self.resolveType2(union_ty.tag_ty, .indirect);
+ member_types.appendAssumeCapacity(tag_ty_ref);
+ member_names.appendAssumeCapacity(try self.spv.resolveString("tag"));
+ }
+
+ if (layout.padding != 0) {
+ const padding_ty_ref = try self.spv.arrayType2(layout.padding, u8_ty_ref);
+ member_types.appendAssumeCapacity(padding_ty_ref);
+ member_names.appendAssumeCapacity(try self.spv.resolveString("padding"));
+ }
+
+ return try self.spv.resolve(.{ .struct_type = .{
+ .member_types = member_types.slice(),
+ .member_names = member_names.slice(),
+ } });
+ }
+
+ fn resolveType2(self: *DeclGen, ty: Type, repr: Repr) Error!SpvCacheRef {
const target = self.getTarget();
switch (ty.zigTypeTag()) {
.Void, .NoReturn => return try self.spv.resolve(.void_type),
@@ -1297,15 +1382,7 @@ pub const DeclGen = struct {
const total_len = std.math.cast(u32, ty.arrayLenIncludingSentinel()) orelse {
return self.fail("array type of {} elements is too large", .{ty.arrayLenIncludingSentinel()});
};
- const len_ty_ref = try self.intType2(.unsigned, 32);
- const len_ref = try self.spv.resolve(.{ .int = .{
- .ty = len_ty_ref,
- .value = .{ .uint64 = total_len },
- } });
- return try self.spv.resolve(.{ .array_type = .{
- .element_type = elem_ty_ref,
- .length = len_ref,
- } });
+ return self.spv.arrayType2(total_len, elem_ty_ref);
},
.Fn => switch (repr) {
.direct => {
@@ -1313,7 +1390,7 @@ pub const DeclGen = struct {
if (ty.fnIsVarArgs())
return self.fail("VarArgs functions are unsupported for SPIR-V", .{});
- const param_ty_refs = try self.gpa.alloc(SpvRef, ty.fnParamLen());
+ const param_ty_refs = try self.gpa.alloc(SpvCacheRef, ty.fnParamLen());
defer self.gpa.free(param_ty_refs);
for (param_ty_refs, 0..) |*param_type, i| {
param_type.* = try self.resolveType2(ty.fnParamType(i), .direct);
@@ -1360,8 +1437,116 @@ pub const DeclGen = struct {
.component_count = @intCast(u32, ty.vectorLen()),
} });
},
+ .Struct => {
+ if (ty.isSimpleTupleOrAnonStruct()) {
+ unreachable; // TODO
+ }
- else => unreachable, // TODO
+ const struct_ty = ty.castTag(.@"struct").?.data;
+
+ if (struct_ty.layout == .Packed) {
+ return try self.resolveType2(struct_ty.backing_int_ty, .direct);
+ }
+
+ const member_types = try self.gpa.alloc(SpvCacheRef, struct_ty.fields.count());
+ defer self.gpa.free(member_types);
+
+ const member_names = try self.gpa.alloc(SpvCacheString, struct_ty.fields.count());
+ defer self.gpa.free(member_names);
+
+ // const members = try self.spv.arena.alloc(SpvType.Payload.Struct.Member, struct_ty.fields.count());
+ var member_index: usize = 0;
+ for (struct_ty.fields.values(), 0..) |field, i| {
+ if (field.is_comptime or !field.ty.hasRuntimeBits()) continue;
+
+ member_types[member_index] = try self.resolveType2(field.ty, .indirect);
+ member_names[member_index] = try self.spv.resolveString(struct_ty.fields.keys()[i]);
+ member_index += 1;
+ }
+
+ const name = try struct_ty.getFullyQualifiedName(self.module);
+ defer self.module.gpa.free(name);
+
+ return try self.spv.resolve(.{ .struct_type = .{
+ .name = try self.spv.resolveString(name),
+ .member_types = member_types[0..member_index],
+ .member_names = member_names[0..member_index],
+ } });
+ },
+ .Optional => {
+ var buf: Type.Payload.ElemType = undefined;
+ const payload_ty = ty.optionalChild(&buf);
+ if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
+ // Just use a bool.
+ // Note: Always generate the bool with indirect format, to save on some sanity
+ // Perform the conversion to a direct bool when the field is extracted.
+ return try self.resolveType2(Type.bool, .indirect);
+ }
+
+ const payload_ty_ref = try self.resolveType2(payload_ty, .indirect);
+ if (ty.optionalReprIsPayload()) {
+ // Optional is actually a pointer or a slice.
+ return payload_ty_ref;
+ }
+
+ const bool_ty_ref = try self.resolveType2(Type.bool, .indirect);
+
+ return try self.spv.resolve(.{ .struct_type = .{
+ .member_types = &.{ payload_ty_ref, bool_ty_ref },
+ .member_names = &.{
+ try self.spv.resolveString("payload"),
+ try self.spv.resolveString("valid"),
+ },
+ } });
+ },
+ .Union => return try self.resolveUnionType2(ty, null),
+ .ErrorSet => return try self.intType2(.unsigned, 16),
+ .ErrorUnion => {
+ const payload_ty = ty.errorUnionPayload();
+ const error_ty_ref = try self.resolveType2(Type.anyerror, .indirect);
+
+ const eu_layout = self.errorUnionLayout(payload_ty);
+ if (!eu_layout.payload_has_bits) {
+ return error_ty_ref;
+ }
+
+ const payload_ty_ref = try self.resolveType2(payload_ty, .indirect);
+
+ var member_types: [2]SpvCacheRef = undefined;
+ var member_names: [2]SpvCacheString = undefined;
+ if (eu_layout.error_first) {
+ // Put the error first
+ member_types = .{ error_ty_ref, payload_ty_ref };
+ member_names = .{
+ try self.spv.resolveString("error"),
+ try self.spv.resolveString("payload"),
+ };
+ // TODO: ABI padding?
+ } else {
+ // Put the payload first.
+ member_types = .{ payload_ty_ref, error_ty_ref };
+ member_names = .{
+ try self.spv.resolveString("payload"),
+ try self.spv.resolveString("error"),
+ };
+ // TODO: ABI padding?
+ }
+
+ return try self.spv.resolve(.{ .struct_type = .{
+ .member_types = &member_types,
+ .member_names = &member_names,
+ } });
+ },
+
+ .Null,
+ .Undefined,
+ .EnumLiteral,
+ .ComptimeFloat,
+ .ComptimeInt,
+ .Type,
+ => unreachable, // Must be comptime.
+
+ else => |tag| return self.todo("Implement zig type '{}'", .{tag}),
}
}