authorgravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2023-10-22 22:17:50+02:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-10-23 06:27:12-04:00
log4bf27da6a6f6cf476ca907dd661c0c40c7c68286
tree4958c6b354d0c134ceb13363027f11424779c528
parent6bf554f9a75b412f3d1f2306dff8c0036555f08c

Revert "Revert "Merge pull request #17657 from Snektron/spirv-recursive-ptrs""

This reverts commit 9f0359d78f9facc38418e32b0e8c1bf6f99f0d26 in an attempt to make the tests pass again. The CI failure from that merge should be unrelated to this commit.

21 files changed, 484 insertions(+), 487 deletions(-)

src/codegen/spirv.zig+292-309
...@@ -209,6 +209,10 @@ const DeclGen = struct {...@@ -209,6 +209,10 @@ const DeclGen = struct {
209 /// See Object.type_map209 /// See Object.type_map
210 type_map: *TypeMap,210 type_map: *TypeMap,
211211
212 /// Child types of pointers that are currently in progress of being resolved. If a pointer
213 /// is already in this map, its recursive.
214 wip_pointers: std.AutoHashMapUnmanaged(struct { InternPool.Index, StorageClass }, CacheRef) = .{},
215
212 /// We need to keep track of result ids for block labels, as well as the 'incoming'216 /// We need to keep track of result ids for block labels, as well as the 'incoming'
213 /// blocks for a block.217 /// blocks for a block.
214 blocks: BlockMap = .{},218 blocks: BlockMap = .{},
...@@ -295,6 +299,7 @@ const DeclGen = struct {...@@ -295,6 +299,7 @@ const DeclGen = struct {
295 pub fn deinit(self: *DeclGen) void {299 pub fn deinit(self: *DeclGen) void {
296 self.args.deinit(self.gpa);300 self.args.deinit(self.gpa);
297 self.inst_results.deinit(self.gpa);301 self.inst_results.deinit(self.gpa);
302 self.wip_pointers.deinit(self.gpa);
298 self.blocks.deinit(self.gpa);303 self.blocks.deinit(self.gpa);
299 self.func.deinit(self.gpa);304 self.func.deinit(self.gpa);
300 self.base_line_stack.deinit(self.gpa);305 self.base_line_stack.deinit(self.gpa);
...@@ -358,8 +363,7 @@ const DeclGen = struct {...@@ -358,8 +363,7 @@ const DeclGen = struct {
358363
359 const mod = self.module;364 const mod = self.module;
360 const ty = mod.intern_pool.typeOf(val).toType();365 const ty = mod.intern_pool.typeOf(val).toType();
361 const ty_ref = try self.resolveType(ty, .indirect);366 const ptr_ty_ref = try self.ptrType(ty, storage_class);
362 const ptr_ty_ref = try self.spv.ptrType(ty_ref, storage_class);
363367
364 const var_id = self.spv.declPtr(spv_decl_index).result_id;368 const var_id = self.spv.declPtr(spv_decl_index).result_id;
365369
...@@ -582,66 +586,41 @@ const DeclGen = struct {...@@ -582,66 +586,41 @@ const DeclGen = struct {
582 }586 }
583587
584 /// Construct a struct at runtime.588 /// Construct a struct at runtime.
585 /// result_ty_ref must be a struct type.589 /// ty must be a struct type.
586 /// Constituents should be in `indirect` representation (as the elements of a struct should be).590 /// Constituents should be in `indirect` representation (as the elements of a struct should be).
587 /// Result is in `direct` representation.591 /// Result is in `direct` representation.
588 fn constructStruct(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {592 fn constructStruct(self: *DeclGen, ty: Type, types: []const Type, constituents: []const IdRef) !IdRef {
593 assert(types.len == constituents.len);
589 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'594 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
590 // operands are not constant.595 // operands are not constant.
591 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349596 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
592 // For now, just initialize the struct by setting the fields manually...597 // For now, just initialize the struct by setting the fields manually...
593 // TODO: Make this OpCompositeConstruct when we can598 // TODO: Make this OpCompositeConstruct when we can
594 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);599 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
595 const ptr_composite_id = self.spv.allocId();600 for (constituents, types, 0..) |constitent_id, member_ty, index| {
596 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{601 const ptr_member_ty_ref = try self.ptrType(member_ty, .Function);
597 .id_result_type = self.typeId(ptr_ty_ref),
598 .id_result = ptr_composite_id,
599 .storage_class = .Function,
600 });
601
602 const spv_composite_ty = self.spv.cache.lookup(result_ty_ref).struct_type;
603 const member_types = spv_composite_ty.member_types;
604
605 for (constituents, member_types, 0..) |constitent_id, member_ty_ref, index| {
606 const ptr_member_ty_ref = try self.spv.ptrType(member_ty_ref, .Function);
607 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});602 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
608 try self.func.body.emit(self.spv.gpa, .OpStore, .{603 try self.func.body.emit(self.spv.gpa, .OpStore, .{
609 .pointer = ptr_id,604 .pointer = ptr_id,
610 .object = constitent_id,605 .object = constitent_id,
611 });606 });
612 }607 }
613 const result_id = self.spv.allocId();608 return try self.load(ty, ptr_composite_id, .{});
614 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
615 .id_result_type = self.typeId(result_ty_ref),
616 .id_result = result_id,
617 .pointer = ptr_composite_id,
618 });
619 return result_id;
620 }609 }
621610
622 /// Construct an array at runtime.611 /// Construct an array at runtime.
623 /// result_ty_ref must be an array type.612 /// ty must be an array type.
624 /// Constituents should be in `indirect` representation (as the elements of an array should be).613 /// Constituents should be in `indirect` representation (as the elements of an array should be).
625 /// Result is in `direct` representation.614 /// Result is in `direct` representation.
626 fn constructArray(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {615 fn constructArray(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef {
627 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'616 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
628 // operands are not constant.617 // operands are not constant.
629 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349618 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
630 // For now, just initialize the struct by setting the fields manually...619 // For now, just initialize the struct by setting the fields manually...
631 // TODO: Make this OpCompositeConstruct when we can620 // TODO: Make this OpCompositeConstruct when we can
632 // TODO: Make this Function storage type621 const mod = self.module;
633 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);622 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
634 const ptr_composite_id = self.spv.allocId();623 const ptr_elem_ty_ref = try self.ptrType(ty.elemType2(mod), .Function);
635 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
636 .id_result_type = self.typeId(ptr_ty_ref),
637 .id_result = ptr_composite_id,
638 .storage_class = .Function,
639 });
640
641 const spv_composite_ty = self.spv.cache.lookup(result_ty_ref).array_type;
642 const elem_ty_ref = spv_composite_ty.element_type;
643 const ptr_elem_ty_ref = try self.spv.ptrType(elem_ty_ref, .Function);
644
645 for (constituents, 0..) |constitent_id, index| {624 for (constituents, 0..) |constitent_id, index| {
646 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});625 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
647 try self.func.body.emit(self.spv.gpa, .OpStore, .{626 try self.func.body.emit(self.spv.gpa, .OpStore, .{
...@@ -649,13 +628,8 @@ const DeclGen = struct {...@@ -649,13 +628,8 @@ const DeclGen = struct {
649 .object = constitent_id,628 .object = constitent_id,
650 });629 });
651 }630 }
652 const result_id = self.spv.allocId();631
653 try self.func.body.emit(self.spv.gpa, .OpLoad, .{632 return try self.load(ty, ptr_composite_id, .{});
654 .id_result_type = self.typeId(result_ty_ref),
655 .id_result = result_id,
656 .pointer = ptr_composite_id,
657 });
658 return result_id;
659 }633 }
660634
661 /// This function generates a load for a constant in direct (ie, non-memory) representation.635 /// This function generates a load for a constant in direct (ie, non-memory) representation.
...@@ -767,15 +741,18 @@ const DeclGen = struct {...@@ -767,15 +741,18 @@ const DeclGen = struct {
767 }.toValue();741 }.toValue();
768742
769 var constituents: [2]IdRef = undefined;743 var constituents: [2]IdRef = undefined;
744 var types: [2]Type = undefined;
770 if (eu_layout.error_first) {745 if (eu_layout.error_first) {
771 constituents[0] = try self.constant(err_ty, err_val, .indirect);746 constituents[0] = try self.constant(err_ty, err_val, .indirect);
772 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);747 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);
748 types = .{ err_ty, payload_ty };
773 } else {749 } else {
774 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);750 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);
775 constituents[1] = try self.constant(err_ty, err_val, .indirect);751 constituents[1] = try self.constant(err_ty, err_val, .indirect);
752 types = .{ payload_ty, err_ty };
776 }753 }
777754
778 return try self.constructStruct(result_ty_ref, &constituents);755 return try self.constructStruct(ty, &types, &constituents);
779 },756 },
780 .enum_tag => {757 .enum_tag => {
781 const int_val = try val.intFromEnum(ty, mod);758 const int_val = try val.intFromEnum(ty, mod);
...@@ -793,7 +770,11 @@ const DeclGen = struct {...@@ -793,7 +770,11 @@ const DeclGen = struct {
793 }770 }
794771
795 const len_id = try self.constant(Type.usize, ptr.len.toValue(), .indirect);772 const len_id = try self.constant(Type.usize, ptr.len.toValue(), .indirect);
796 return try self.constructStruct(result_ty_ref, &.{ ptr_id, len_id });773 return try self.constructStruct(
774 ty,
775 &.{ ptr_ty, Type.usize },
776 &.{ ptr_id, len_id },
777 );
797 },778 },
798 .opt => {779 .opt => {
799 const payload_ty = ty.optionalChild(mod);780 const payload_ty = ty.optionalChild(mod);
...@@ -820,7 +801,11 @@ const DeclGen = struct {...@@ -820,7 +801,11 @@ const DeclGen = struct {
820 else801 else
821 try self.spv.constUndef(try self.resolveType(payload_ty, .indirect));802 try self.spv.constUndef(try self.resolveType(payload_ty, .indirect));
822803
823 return try self.constructStruct(result_ty_ref, &.{ payload_id, has_pl_id });804 return try self.constructStruct(
805 ty,
806 &.{ payload_ty, Type.bool },
807 &.{ payload_id, has_pl_id },
808 );
824 },809 },
825 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {810 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {
826 inline .array_type, .vector_type => |array_type, tag| {811 inline .array_type, .vector_type => |array_type, tag| {
...@@ -858,7 +843,7 @@ const DeclGen = struct {...@@ -858,7 +843,7 @@ const DeclGen = struct {
858 else => {},843 else => {},
859 }844 }
860845
861 return try self.constructArray(result_ty_ref, constituents);846 return try self.constructArray(ty, constituents);
862 },847 },
863 .struct_type => {848 .struct_type => {
864 const struct_type = mod.typeToStruct(ty).?;849 const struct_type = mod.typeToStruct(ty).?;
...@@ -866,6 +851,9 @@ const DeclGen = struct {...@@ -866,6 +851,9 @@ const DeclGen = struct {
866 return self.todo("packed struct constants", .{});851 return self.todo("packed struct constants", .{});
867 }852 }
868853
854 var types = std.ArrayList(Type).init(self.gpa);
855 defer types.deinit();
856
869 var constituents = std.ArrayList(IdRef).init(self.gpa);857 var constituents = std.ArrayList(IdRef).init(self.gpa);
870 defer constituents.deinit();858 defer constituents.deinit();
871859
...@@ -881,22 +869,23 @@ const DeclGen = struct {...@@ -881,22 +869,23 @@ const DeclGen = struct {
881 const field_val = try val.fieldValue(mod, field_index);869 const field_val = try val.fieldValue(mod, field_index);
882 const field_id = try self.constant(field_ty, field_val, .indirect);870 const field_id = try self.constant(field_ty, field_val, .indirect);
883871
872 try types.append(field_ty);
884 try constituents.append(field_id);873 try constituents.append(field_id);
885 }874 }
886875
887 return try self.constructStruct(result_ty_ref, constituents.items);876 return try self.constructStruct(ty, types.items, constituents.items);
888 },877 },
889 .anon_struct_type => unreachable, // TODO878 .anon_struct_type => unreachable, // TODO
890 else => unreachable,879 else => unreachable,
891 },880 },
892 .un => |un| {881 .un => |un| {
893 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;882 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;
894 const layout = self.unionLayout(ty, active_field);883 const union_obj = mod.typeToUnion(ty).?;
895 const payload = if (layout.active_field_size != 0)884 const field_ty = union_obj.field_types.get(ip)[active_field].toType();
896 try self.constant(layout.active_field_ty, un.val.toValue(), .indirect)885 const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(mod))
886 try self.constant(field_ty, un.val.toValue(), .direct)
897 else887 else
898 null;888 null;
899
900 return try self.unionInit(ty, active_field, payload);889 return try self.unionInit(ty, active_field, payload);
901 },890 },
902 .memoized_call => unreachable,891 .memoized_call => unreachable,
...@@ -935,8 +924,7 @@ const DeclGen = struct {...@@ -935,8 +924,7 @@ const DeclGen = struct {
935924
936 // TODO: Can we consolidate this in ptrElemPtr?925 // TODO: Can we consolidate this in ptrElemPtr?
937 const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.926 const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
938 const elem_ty_ref = try self.resolveType(elem_ty, .direct);927 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
939 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
940928
941 if (elem_ptr_ty_ref == result_ty_ref) {929 if (elem_ptr_ty_ref == result_ty_ref) {
942 return elem_ptr_id;930 return elem_ptr_id;
...@@ -998,8 +986,7 @@ const DeclGen = struct {...@@ -998,8 +986,7 @@ const DeclGen = struct {
998 };986 };
999987
1000 const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);988 const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);
1001 const decl_ty_ref = try self.resolveType(decl_ty, .indirect);989 const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class);
1002 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
1003990
1004 const ptr_id = switch (final_storage_class) {991 const ptr_id = switch (final_storage_class) {
1005 .Generic => blk: {992 .Generic => blk: {
...@@ -1055,8 +1042,7 @@ const DeclGen = struct {...@@ -1055,8 +1042,7 @@ const DeclGen = struct {
10551042
1056 const final_storage_class = spvStorageClass(decl.@"addrspace");1043 const final_storage_class = spvStorageClass(decl.@"addrspace");
10571044
1058 const decl_ty_ref = try self.resolveType(decl.ty, .indirect);1045 const decl_ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);
1059 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
10601046
1061 const ptr_id = switch (final_storage_class) {1047 const ptr_id = switch (final_storage_class) {
1062 .Generic => blk: {1048 .Generic => blk: {
...@@ -1124,29 +1110,52 @@ const DeclGen = struct {...@@ -1124,29 +1110,52 @@ const DeclGen = struct {
1124 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());1110 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());
1125 }1111 }
11261112
1127 /// Generate a union type, optionally with a known field. If the tag alignment is greater1113 fn ptrType(self: *DeclGen, child_ty: Type, storage_class: StorageClass) !CacheRef {
1128 /// than that of the payload, a regular union (non-packed, with both tag and payload), will1114 const key = .{ child_ty.toIntern(), storage_class };
1129 /// be generated as follows:1115 const entry = try self.wip_pointers.getOrPut(self.gpa, key);
1130 /// If the active field is known:1116 if (entry.found_existing) {
1117 const fwd_ref = entry.value_ptr.*;
1118 try self.spv.cache.recursive_ptrs.put(self.spv.gpa, fwd_ref, {});
1119 return fwd_ref;
1120 }
1121
1122 const fwd_ref = try self.spv.resolve(.{ .fwd_ptr_type = .{
1123 .zig_child_type = child_ty.toIntern(),
1124 .storage_class = storage_class,
1125 } });
1126 entry.value_ptr.* = fwd_ref;
1127
1128 const child_ty_ref = try self.resolveType(child_ty, .indirect);
1129 _ = try self.spv.resolve(.{ .ptr_type = .{
1130 .storage_class = storage_class,
1131 .child_type = child_ty_ref,
1132 .fwd = fwd_ref,
1133 } });
1134
1135 assert(self.wip_pointers.remove(key));
1136
1137 return fwd_ref;
1138 }
1139
1140 /// Generate a union type. Union types are always generated with the
1141 /// most aligned field active. If the tag alignment is greater
1142 /// than that of the payload, a regular union (non-packed, with both tag and
1143 /// payload), will be generated as follows:
1131 /// struct {1144 /// struct {
1132 /// tag: TagType,1145 /// tag: TagType,
1133 /// payload: ActivePayloadType,1146 /// payload: MostAlignedFieldType,
1134 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,1147 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1135 /// padding: [padding_size]u8,1148 /// padding: [padding_size]u8,
1136 /// }1149 /// }
1137 /// If the payload alignment is greater than that of the tag:1150 /// If the payload alignment is greater than that of the tag:
1138 /// struct {1151 /// struct {
1139 /// payload: ActivePayloadType,1152 /// payload: MostAlignedFieldType,
1140 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,1153 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1141 /// tag: TagType,1154 /// tag: TagType,
1142 /// padding: [padding_size]u8,1155 /// padding: [padding_size]u8,
1143 /// }1156 /// }
1144 /// If the active payload is unknown, it will default back to the most aligned field. This is
1145 /// to make sure that the overal struct has the correct alignment in spir-v.
1146 /// If any of the fields' size is 0, it will be omitted.1157 /// If any of the fields' size is 0, it will be omitted.
1147 /// NOTE: When the active field is set to something other than the most aligned field, the1158 fn resolveUnionType(self: *DeclGen, ty: Type) !CacheRef {
1148 /// resulting struct will be *underaligned*.
1149 fn resolveUnionType(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !CacheRef {
1150 const mod = self.module;1159 const mod = self.module;
1151 const ip = &mod.intern_pool;1160 const ip = &mod.intern_pool;
1152 const union_obj = mod.typeToUnion(ty).?;1161 const union_obj = mod.typeToUnion(ty).?;
...@@ -1155,17 +1164,13 @@ const DeclGen = struct {...@@ -1155,17 +1164,13 @@ const DeclGen = struct {
1155 return self.todo("packed union types", .{});1164 return self.todo("packed union types", .{});
1156 }1165 }
11571166
1158 const layout = self.unionLayout(ty, maybe_active_field);1167 const layout = self.unionLayout(ty);
11591168 if (!layout.has_payload) {
1160 if (layout.payload_size == 0) {
1161 // No payload, so represent this as just the tag type.1169 // No payload, so represent this as just the tag type.
1162 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);1170 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);
1163 }1171 }
11641172
1165 // TODO: We need to add the active field to the key, somehow.1173 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1166 if (maybe_active_field == null) {
1167 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1168 }
11691174
1170 var member_types: [4]CacheRef = undefined;1175 var member_types: [4]CacheRef = undefined;
1171 var member_names: [4]CacheString = undefined;1176 var member_names: [4]CacheString = undefined;
...@@ -1178,10 +1183,10 @@ const DeclGen = struct {...@@ -1178,10 +1183,10 @@ const DeclGen = struct {
1178 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");1183 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");
1179 }1184 }
11801185
1181 if (layout.active_field_size != 0) {1186 if (layout.payload_size != 0) {
1182 const active_payload_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);1187 const payload_ty_ref = try self.resolveType(layout.payload_ty, .indirect);
1183 member_types[layout.active_field_index] = active_payload_ty_ref;1188 member_types[layout.payload_index] = payload_ty_ref;
1184 member_names[layout.active_field_index] = try self.spv.resolveString("(payload)");1189 member_names[layout.payload_index] = try self.spv.resolveString("(payload)");
1185 }1190 }
11861191
1187 if (layout.payload_padding_size != 0) {1192 if (layout.payload_padding_size != 0) {
...@@ -1202,9 +1207,7 @@ const DeclGen = struct {...@@ -1202,9 +1207,7 @@ const DeclGen = struct {
1202 .member_names = member_names[0..layout.total_fields],1207 .member_names = member_names[0..layout.total_fields],
1203 } });1208 } });
12041209
1205 if (maybe_active_field == null) {1210 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1206 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1207 }
1208 return ty_ref;1211 return ty_ref;
1209 }1212 }
12101213
...@@ -1352,12 +1355,12 @@ const DeclGen = struct {...@@ -1352,12 +1355,12 @@ const DeclGen = struct {
1352 .Pointer => {1355 .Pointer => {
1353 const ptr_info = ty.ptrInfo(mod);1356 const ptr_info = ty.ptrInfo(mod);
13541357
1358 // Note: Don't cache this pointer type, it would mess up the recursive pointer functionality
1359 // in ptrType()!
1360
1355 const storage_class = spvStorageClass(ptr_info.flags.address_space);1361 const storage_class = spvStorageClass(ptr_info.flags.address_space);
1356 const child_ty_ref = try self.resolveType(ptr_info.child.toType(), .indirect);1362 const ptr_ty_ref = try self.ptrType(ptr_info.child.toType(), storage_class);
1357 const ptr_ty_ref = try self.spv.resolve(.{ .ptr_type = .{1363
1358 .storage_class = storage_class,
1359 .child_type = child_ty_ref,
1360 } });
1361 if (ptr_info.flags.size != .Slice) {1364 if (ptr_info.flags.size != .Slice) {
1362 return ptr_ty_ref;1365 return ptr_ty_ref;
1363 }1366 }
...@@ -1472,7 +1475,7 @@ const DeclGen = struct {...@@ -1472,7 +1475,7 @@ const DeclGen = struct {
1472 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });1475 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1473 return ty_ref;1476 return ty_ref;
1474 },1477 },
1475 .Union => return try self.resolveUnionType(ty, null),1478 .Union => return try self.resolveUnionType(ty),
1476 .ErrorSet => return try self.intType(.unsigned, 16),1479 .ErrorSet => return try self.intType(.unsigned, 16),
1477 .ErrorUnion => {1480 .ErrorUnion => {
1478 const payload_ty = ty.errorUnionPayload(mod);1481 const payload_ty = ty.errorUnionPayload(mod);
...@@ -1586,14 +1589,16 @@ const DeclGen = struct {...@@ -1586,14 +1589,16 @@ const DeclGen = struct {
1586 }1589 }
15871590
1588 const UnionLayout = struct {1591 const UnionLayout = struct {
1589 active_field: u32,1592 /// If false, this union is represented
1590 active_field_ty: Type,1593 /// by only an integer of the tag type.
1591 payload_size: u32,1594 has_payload: bool,
1592
1593 tag_size: u32,1595 tag_size: u32,
1594 tag_index: u32,1596 tag_index: u32,
1595 active_field_size: u32,1597 /// Note: This is the size of the payload type itself, NOT the size of the ENTIRE payload.
1596 active_field_index: u32,1598 /// Use `has_payload` instead!!
1599 payload_ty: Type,
1600 payload_size: u32,
1601 payload_index: u32,
1597 payload_padding_size: u32,1602 payload_padding_size: u32,
1598 payload_padding_index: u32,1603 payload_padding_index: u32,
1599 padding_size: u32,1604 padding_size: u32,
...@@ -1601,23 +1606,19 @@ const DeclGen = struct {...@@ -1601,23 +1606,19 @@ const DeclGen = struct {
1601 total_fields: u32,1606 total_fields: u32,
1602 };1607 };
16031608
1604 fn unionLayout(self: *DeclGen, ty: Type, maybe_active_field: ?usize) UnionLayout {1609 fn unionLayout(self: *DeclGen, ty: Type) UnionLayout {
1605 const mod = self.module;1610 const mod = self.module;
1606 const ip = &mod.intern_pool;1611 const ip = &mod.intern_pool;
1607 const layout = ty.unionGetLayout(self.module);1612 const layout = ty.unionGetLayout(self.module);
1608 const union_obj = mod.typeToUnion(ty).?;1613 const union_obj = mod.typeToUnion(ty).?;
16091614
1610 const active_field = maybe_active_field orelse layout.most_aligned_field;
1611 const active_field_ty = union_obj.field_types.get(ip)[active_field].toType();
1612
1613 var union_layout = UnionLayout{1615 var union_layout = UnionLayout{
1614 .active_field = @intCast(active_field),1616 .has_payload = layout.payload_size != 0,
1615 .active_field_ty = active_field_ty,
1616 .payload_size = @intCast(layout.payload_size),
1617 .tag_size = @intCast(layout.tag_size),1617 .tag_size = @intCast(layout.tag_size),
1618 .tag_index = undefined,1618 .tag_index = undefined,
1619 .active_field_size = undefined,1619 .payload_ty = undefined,
1620 .active_field_index = undefined,1620 .payload_size = undefined,
1621 .payload_index = undefined,
1621 .payload_padding_size = undefined,1622 .payload_padding_size = undefined,
1622 .payload_padding_index = undefined,1623 .payload_padding_index = undefined,
1623 .padding_size = @intCast(layout.padding),1624 .padding_size = @intCast(layout.padding),
...@@ -1625,11 +1626,16 @@ const DeclGen = struct {...@@ -1625,11 +1626,16 @@ const DeclGen = struct {
1625 .total_fields = undefined,1626 .total_fields = undefined,
1626 };1627 };
16271628
1628 union_layout.active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime(mod))1629 if (union_layout.has_payload) {
1629 @intCast(active_field_ty.abiSize(mod))1630 const most_aligned_field = layout.most_aligned_field;
1630 else1631 const most_aligned_field_ty = union_obj.field_types.get(ip)[most_aligned_field].toType();
1631 0;1632 union_layout.payload_ty = most_aligned_field_ty;
1632 union_layout.payload_padding_size = @intCast(layout.payload_size - union_layout.active_field_size);1633 union_layout.payload_size = @intCast(most_aligned_field_ty.abiSize(mod));
1634 } else {
1635 union_layout.payload_size = 0;
1636 }
1637
1638 union_layout.payload_padding_size = @intCast(layout.payload_size - union_layout.payload_size);
16331639
1634 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);1640 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);
1635 var field_index: u32 = 0;1641 var field_index: u32 = 0;
...@@ -1639,8 +1645,8 @@ const DeclGen = struct {...@@ -1639,8 +1645,8 @@ const DeclGen = struct {
1639 field_index += 1;1645 field_index += 1;
1640 }1646 }
16411647
1642 if (union_layout.active_field_size != 0) {1648 if (union_layout.payload_size != 0) {
1643 union_layout.active_field_index = field_index;1649 union_layout.payload_index = field_index;
1644 field_index += 1;1650 field_index += 1;
1645 }1651 }
16461652
...@@ -1684,7 +1690,7 @@ const DeclGen = struct {...@@ -1684,7 +1690,7 @@ const DeclGen = struct {
1684 /// the name of an error in the text executor.1690 /// the name of an error in the text executor.
1685 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {1691 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {
1686 const anyerror_ty_ref = try self.resolveType(Type.anyerror, .direct);1692 const anyerror_ty_ref = try self.resolveType(Type.anyerror, .direct);
1687 const ptr_anyerror_ty_ref = try self.spv.ptrType(anyerror_ty_ref, .CrossWorkgroup);1693 const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup);
1688 const void_ty_ref = try self.resolveType(Type.void, .direct);1694 const void_ty_ref = try self.resolveType(Type.void, .direct);
16891695
1690 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{1696 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
...@@ -1719,6 +1725,7 @@ const DeclGen = struct {...@@ -1719,6 +1725,7 @@ const DeclGen = struct {
1719 .id_result = error_id,1725 .id_result = error_id,
1720 .function = test_id,1726 .function = test_id,
1721 });1727 });
1728 // Note: Convert to direct not required.
1722 try section.emit(self.spv.gpa, .OpStore, .{1729 try section.emit(self.spv.gpa, .OpStore, .{
1723 .pointer = p_error_id,1730 .pointer = p_error_id,
1724 .object = error_id,1731 .object = error_id,
...@@ -1823,8 +1830,7 @@ const DeclGen = struct {...@@ -1823,8 +1830,7 @@ const DeclGen = struct {
1823 else => final_storage_class,1830 else => final_storage_class,
1824 };1831 };
18251832
1826 const ty_ref = try self.resolveType(decl.ty, .indirect);1833 const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class);
1827 const ptr_ty_ref = try self.spv.ptrType(ty_ref, actual_storage_class);
18281834
1829 const begin = self.spv.beginGlobal();1835 const begin = self.spv.beginGlobal();
1830 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{1836 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{
...@@ -1929,11 +1935,15 @@ const DeclGen = struct {...@@ -1929,11 +1935,15 @@ const DeclGen = struct {
1929 return try self.convertToDirect(result_ty, result_id);1935 return try self.convertToDirect(result_ty, result_id);
1930 }1936 }
19311937
1932 fn load(self: *DeclGen, value_ty: Type, ptr_id: IdRef, is_volatile: bool) !IdRef {1938 const MemoryOptions = struct {
1939 is_volatile: bool = false,
1940 };
1941
1942 fn load(self: *DeclGen, value_ty: Type, ptr_id: IdRef, options: MemoryOptions) !IdRef {
1933 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);1943 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
1934 const result_id = self.spv.allocId();1944 const result_id = self.spv.allocId();
1935 const access = spec.MemoryAccess.Extended{1945 const access = spec.MemoryAccess.Extended{
1936 .Volatile = is_volatile,1946 .Volatile = options.is_volatile,
1937 };1947 };
1938 try self.func.body.emit(self.spv.gpa, .OpLoad, .{1948 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
1939 .id_result_type = self.typeId(indirect_value_ty_ref),1949 .id_result_type = self.typeId(indirect_value_ty_ref),
...@@ -1944,10 +1954,10 @@ const DeclGen = struct {...@@ -1944,10 +1954,10 @@ const DeclGen = struct {
1944 return try self.convertToDirect(value_ty, result_id);1954 return try self.convertToDirect(value_ty, result_id);
1945 }1955 }
19461956
1947 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, is_volatile: bool) !void {1957 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, options: MemoryOptions) !void {
1948 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);1958 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
1949 const access = spec.MemoryAccess.Extended{1959 const access = spec.MemoryAccess.Extended{
1950 .Volatile = is_volatile,1960 .Volatile = options.is_volatile,
1951 };1961 };
1952 try self.func.body.emit(self.spv.gpa, .OpStore, .{1962 try self.func.body.emit(self.spv.gpa, .OpStore, .{
1953 .pointer = ptr_id,1963 .pointer = ptr_id,
...@@ -2119,9 +2129,7 @@ const DeclGen = struct {...@@ -2119,9 +2129,7 @@ const DeclGen = struct {
2119 constituent.* = try self.convertToIndirect(child_ty, result_id);2129 constituent.* = try self.convertToIndirect(child_ty, result_id);
2120 }2130 }
21212131
2122 const result_ty = try self.resolveType(child_ty, .indirect);2132 return try self.constructArray(ty, constituents);
2123 const result_ty_ref = try self.spv.arrayType(vector_len, result_ty);
2124 return try self.constructArray(result_ty_ref, constituents);
2125 }2133 }
21262134
2127 const result_id = self.spv.allocId();2135 const result_id = self.spv.allocId();
...@@ -2182,7 +2190,7 @@ const DeclGen = struct {...@@ -2182,7 +2190,7 @@ const DeclGen = struct {
21822190
2183 const info = try self.arithmeticTypeInfo(result_ty);2191 const info = try self.arithmeticTypeInfo(result_ty);
2184 // TODO: Use fmin for OpenCL2192 // TODO: Use fmin for OpenCL
2185 const cmp_id = try self.cmp(op, result_ty, lhs_id, rhs_id);2193 const cmp_id = try self.cmp(op, Type.bool, result_ty, lhs_id, rhs_id);
2186 const selection_id = switch (info.class) {2194 const selection_id = switch (info.class) {
2187 .float => blk: {2195 .float => blk: {
2188 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,2196 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,
...@@ -2317,7 +2325,7 @@ const DeclGen = struct {...@@ -2317,7 +2325,7 @@ const DeclGen = struct {
2317 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);2325 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);
2318 }2326 }
23192327
2320 return self.constructArray(result_ty_ref, constituents);2328 return self.constructArray(ty, constituents);
2321 }2329 }
23222330
2323 // Binary operations are generally applicable to both scalar and vector operations2331 // Binary operations are generally applicable to both scalar and vector operations
...@@ -2473,11 +2481,11 @@ const DeclGen = struct {...@@ -2473,11 +2481,11 @@ const DeclGen = struct {
2473 // Construct the struct that Zig wants as result.2481 // Construct the struct that Zig wants as result.
2474 // The value should already be the correct type.2482 // The value should already be the correct type.
2475 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);2483 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);
2476 const result_ty_ref = try self.resolveType(result_ty, .direct);2484 return try self.constructStruct(
2477 return try self.constructStruct(result_ty_ref, &.{2485 result_ty,
2478 value_id,2486 &.{ operand_ty, ov_ty },
2479 ov_id,2487 &.{ value_id, ov_id },
2480 });2488 );
2481 }2489 }
24822490
2483 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2491 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -2635,6 +2643,7 @@ const DeclGen = struct {...@@ -2635,6 +2643,7 @@ const DeclGen = struct {
2635 fn cmp(2643 fn cmp(
2636 self: *DeclGen,2644 self: *DeclGen,
2637 op: std.math.CompareOperator,2645 op: std.math.CompareOperator,
2646 result_ty: Type,
2638 ty: Type,2647 ty: Type,
2639 lhs_id: IdRef,2648 lhs_id: IdRef,
2640 rhs_id: IdRef,2649 rhs_id: IdRef,
...@@ -2675,7 +2684,7 @@ const DeclGen = struct {...@@ -2675,7 +2684,7 @@ const DeclGen = struct {
2675 if (ty.optionalReprIsPayload(mod)) {2684 if (ty.optionalReprIsPayload(mod)) {
2676 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));2685 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));
2677 assert(!payload_ty.isSlice(mod));2686 assert(!payload_ty.isSlice(mod));
2678 return self.cmp(op, payload_ty, lhs_id, rhs_id);2687 return self.cmp(op, Type.bool, payload_ty, lhs_id, rhs_id);
2679 }2688 }
26802689
2681 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))2690 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
...@@ -2688,7 +2697,7 @@ const DeclGen = struct {...@@ -2688,7 +2697,7 @@ const DeclGen = struct {
2688 else2697 else
2689 try self.convertToDirect(Type.bool, rhs_id);2698 try self.convertToDirect(Type.bool, rhs_id);
26902699
2691 const valid_cmp_id = try self.cmp(op, Type.bool, lhs_valid_id, rhs_valid_id);2700 const valid_cmp_id = try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id);
2692 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {2701 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
2693 return valid_cmp_id;2702 return valid_cmp_id;
2694 }2703 }
...@@ -2699,7 +2708,7 @@ const DeclGen = struct {...@@ -2699,7 +2708,7 @@ const DeclGen = struct {
2699 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);2708 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);
2700 const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);2709 const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);
27012710
2702 const pl_cmp_id = try self.cmp(op, payload_ty, lhs_pl_id, rhs_pl_id);2711 const pl_cmp_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id);
27032712
2704 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl2713 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl
2705 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl2714 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl
...@@ -2721,7 +2730,6 @@ const DeclGen = struct {...@@ -2721,7 +2730,6 @@ const DeclGen = struct {
2721 .Vector => {2730 .Vector => {
2722 const child_ty = ty.childType(mod);2731 const child_ty = ty.childType(mod);
2723 const vector_len = ty.vectorLen(mod);2732 const vector_len = ty.vectorLen(mod);
2724 const bool_ty_ref_indirect = try self.resolveType(Type.bool, .indirect);
27252733
2726 var constituents = try self.gpa.alloc(IdRef, vector_len);2734 var constituents = try self.gpa.alloc(IdRef, vector_len);
2727 defer self.gpa.free(constituents);2735 defer self.gpa.free(constituents);
...@@ -2729,12 +2737,11 @@ const DeclGen = struct {...@@ -2729,12 +2737,11 @@ const DeclGen = struct {
2729 for (constituents, 0..) |*constituent, i| {2737 for (constituents, 0..) |*constituent, i| {
2730 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));2738 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));
2731 const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));2739 const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));
2732 const result_id = try self.cmp(op, child_ty, lhs_index_id, rhs_index_id);2740 const result_id = try self.cmp(op, Type.bool, child_ty, lhs_index_id, rhs_index_id);
2733 constituent.* = try self.convertToIndirect(Type.bool, result_id);2741 constituent.* = try self.convertToIndirect(Type.bool, result_id);
2734 }2742 }
27352743
2736 const result_ty_ref = try self.spv.arrayType(vector_len, bool_ty_ref_indirect);2744 return try self.constructArray(result_ty, constituents);
2737 return try self.constructArray(result_ty_ref, constituents);
2738 },2745 },
2739 else => unreachable,2746 else => unreachable,
2740 };2747 };
...@@ -2807,8 +2814,9 @@ const DeclGen = struct {...@@ -2807,8 +2814,9 @@ const DeclGen = struct {
2807 const lhs_id = try self.resolve(bin_op.lhs);2814 const lhs_id = try self.resolve(bin_op.lhs);
2808 const rhs_id = try self.resolve(bin_op.rhs);2815 const rhs_id = try self.resolve(bin_op.rhs);
2809 const ty = self.typeOf(bin_op.lhs);2816 const ty = self.typeOf(bin_op.lhs);
2817 const result_ty = self.typeOfIndex(inst);
28102818
2811 return try self.cmp(op, ty, lhs_id, rhs_id);2819 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
2812 }2820 }
28132821
2814 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2822 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -2820,8 +2828,9 @@ const DeclGen = struct {...@@ -2820,8 +2828,9 @@ const DeclGen = struct {
2820 const rhs_id = try self.resolve(vec_cmp.rhs);2828 const rhs_id = try self.resolve(vec_cmp.rhs);
2821 const op = vec_cmp.compareOperator();2829 const op = vec_cmp.compareOperator();
2822 const ty = self.typeOf(vec_cmp.lhs);2830 const ty = self.typeOf(vec_cmp.lhs);
2831 const result_ty = self.typeOfIndex(inst);
28232832
2824 return try self.cmp(op, ty, lhs_id, rhs_id);2833 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
2825 }2834 }
28262835
2827 fn bitCast(2836 fn bitCast(
...@@ -2866,23 +2875,17 @@ const DeclGen = struct {...@@ -2866,23 +2875,17 @@ const DeclGen = struct {
2866 return result_id;2875 return result_id;
2867 }2876 }
28682877
2869 const src_ptr_ty_ref = try self.spv.ptrType(src_ty_ref, .Function);2878 const dst_ptr_ty_ref = try self.ptrType(dst_ty, .Function);
2870 const dst_ptr_ty_ref = try self.spv.ptrType(dst_ty_ref, .Function);
28712879
2872 const tmp_id = self.spv.allocId();2880 const tmp_id = try self.alloc(src_ty, .{ .storage_class = .Function });
2873 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{2881 try self.store(src_ty, tmp_id, src_id, .{});
2874 .id_result_type = self.typeId(src_ptr_ty_ref),
2875 .id_result = tmp_id,
2876 .storage_class = .Function,
2877 });
2878 try self.store(src_ty, tmp_id, src_id, false);
2879 const casted_ptr_id = self.spv.allocId();2882 const casted_ptr_id = self.spv.allocId();
2880 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{2883 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
2881 .id_result_type = self.typeId(dst_ptr_ty_ref),2884 .id_result_type = self.typeId(dst_ptr_ty_ref),
2882 .id_result = casted_ptr_id,2885 .id_result = casted_ptr_id,
2883 .operand = tmp_id,2886 .operand = tmp_id,
2884 });2887 });
2885 return try self.load(dst_ty, casted_ptr_id, false);2888 return try self.load(dst_ty, casted_ptr_id, .{});
2886 }2889 }
28872890
2888 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2891 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3061,7 +3064,6 @@ const DeclGen = struct {...@@ -3061,7 +3064,6 @@ const DeclGen = struct {
3061 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);3064 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
30623065
3063 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);3066 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);
3064 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
3065 const size_ty_ref = try self.sizeType();3067 const size_ty_ref = try self.sizeType();
30663068
3067 const array_ptr_id = try self.resolve(ty_op.operand);3069 const array_ptr_id = try self.resolve(ty_op.operand);
...@@ -3074,7 +3076,11 @@ const DeclGen = struct {...@@ -3074,7 +3076,11 @@ const DeclGen = struct {
3074 // Convert the pointer-to-array to a pointer to the first element.3076 // Convert the pointer-to-array to a pointer to the first element.
3075 try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});3077 try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});
30763078
3077 return try self.constructStruct(slice_ty_ref, &.{ elem_ptr_id, len_id });3079 return try self.constructStruct(
3080 slice_ty,
3081 &.{ elem_ptr_ty, Type.usize },
3082 &.{ elem_ptr_id, len_id },
3083 );
3078 }3084 }
30793085
3080 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3086 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3084,13 +3090,16 @@ const DeclGen = struct {...@@ -3084,13 +3090,16 @@ const DeclGen = struct {
3084 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;3090 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
3085 const ptr_id = try self.resolve(bin_op.lhs);3091 const ptr_id = try self.resolve(bin_op.lhs);
3086 const len_id = try self.resolve(bin_op.rhs);3092 const len_id = try self.resolve(bin_op.rhs);
3093 const ptr_ty = self.typeOf(bin_op.lhs);
3087 const slice_ty = self.typeOfIndex(inst);3094 const slice_ty = self.typeOfIndex(inst);
3088 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
30893095
3090 return try self.constructStruct(slice_ty_ref, &.{3096 // Note: Types should not need to be converted to direct, these types
3091 ptr_id, // Note: Type should not need to be converted to direct.3097 // dont need to be converted.
3092 len_id, // Note: Type should not need to be converted to direct.3098 return try self.constructStruct(
3093 });3099 slice_ty,
3100 &.{ ptr_ty, Type.usize },
3101 &.{ ptr_id, len_id },
3102 );
3094 }3103 }
30953104
3096 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3105 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3100,7 +3109,6 @@ const DeclGen = struct {...@@ -3100,7 +3109,6 @@ const DeclGen = struct {
3100 const ip = &mod.intern_pool;3109 const ip = &mod.intern_pool;
3101 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;3110 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
3102 const result_ty = self.typeOfIndex(inst);3111 const result_ty = self.typeOfIndex(inst);
3103 const result_ty_ref = try self.resolveType(result_ty, .direct);
3104 const len: usize = @intCast(result_ty.arrayLen(mod));3112 const len: usize = @intCast(result_ty.arrayLen(mod));
3105 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);3113 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
31063114
...@@ -3112,6 +3120,8 @@ const DeclGen = struct {...@@ -3112,6 +3120,8 @@ const DeclGen = struct {
3112 unreachable; // TODO3120 unreachable; // TODO
3113 }3121 }
31143122
3123 const types = try self.gpa.alloc(Type, elements.len);
3124 defer self.gpa.free(types);
3115 const constituents = try self.gpa.alloc(IdRef, elements.len);3125 const constituents = try self.gpa.alloc(IdRef, elements.len);
3116 defer self.gpa.free(constituents);3126 defer self.gpa.free(constituents);
3117 var index: usize = 0;3127 var index: usize = 0;
...@@ -3123,6 +3133,7 @@ const DeclGen = struct {...@@ -3123,6 +3133,7 @@ const DeclGen = struct {
3123 assert(field_ty.toType().hasRuntimeBits(mod));3133 assert(field_ty.toType().hasRuntimeBits(mod));
31243134
3125 const id = try self.resolve(element);3135 const id = try self.resolve(element);
3136 types[index] = field_ty.toType();
3126 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);3137 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);
3127 index += 1;3138 index += 1;
3128 }3139 }
...@@ -3136,6 +3147,7 @@ const DeclGen = struct {...@@ -3136,6 +3147,7 @@ const DeclGen = struct {
3136 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));3147 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));
31373148
3138 const id = try self.resolve(element);3149 const id = try self.resolve(element);
3150 types[index] = field_ty;
3139 constituents[index] = try self.convertToIndirect(field_ty, id);3151 constituents[index] = try self.convertToIndirect(field_ty, id);
3140 index += 1;3152 index += 1;
3141 }3153 }
...@@ -3143,7 +3155,11 @@ const DeclGen = struct {...@@ -3143,7 +3155,11 @@ const DeclGen = struct {
3143 else => unreachable,3155 else => unreachable,
3144 }3156 }
31453157
3146 return try self.constructStruct(result_ty_ref, constituents[0..index]);3158 return try self.constructStruct(
3159 result_ty,
3160 types[0..index],
3161 constituents[0..index],
3162 );
3147 },3163 },
3148 .Array => {3164 .Array => {
3149 const array_info = result_ty.arrayInfo(mod);3165 const array_info = result_ty.arrayInfo(mod);
...@@ -3160,7 +3176,7 @@ const DeclGen = struct {...@@ -3160,7 +3176,7 @@ const DeclGen = struct {
3160 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);3176 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);
3161 }3177 }
31623178
3163 return try self.constructArray(result_ty_ref, elem_ids);3179 return try self.constructArray(result_ty, elem_ids);
3164 },3180 },
3165 else => unreachable,3181 else => unreachable,
3166 }3182 }
...@@ -3245,15 +3261,14 @@ const DeclGen = struct {...@@ -3245,15 +3261,14 @@ const DeclGen = struct {
32453261
3246 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);3262 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
3247 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});3263 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});
3248 return try self.load(slice_ty.childType(mod), elem_ptr, slice_ty.isVolatilePtr(mod));3264 return try self.load(slice_ty.childType(mod), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(mod) });
3249 }3265 }
32503266
3251 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {3267 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
3252 const mod = self.module;3268 const mod = self.module;
3253 // Construct new pointer type for the resulting pointer3269 // Construct new pointer type for the resulting pointer
3254 const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.3270 const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
3255 const elem_ty_ref = try self.resolveType(elem_ty, .direct);3271 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
3256 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
3257 if (ptr_ty.isSinglePointer(mod)) {3272 if (ptr_ty.isSinglePointer(mod)) {
3258 // Pointer-to-array. In this case, the resulting pointer is not of the same type3273 // Pointer-to-array. In this case, the resulting pointer is not of the same type
3259 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.3274 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.
...@@ -3289,9 +3304,7 @@ const DeclGen = struct {...@@ -3289,9 +3304,7 @@ const DeclGen = struct {
3289 const mod = self.module;3304 const mod = self.module;
3290 const bin_op = self.air.instructions.items(.data)[inst].bin_op;3305 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
3291 const array_ty = self.typeOf(bin_op.lhs);3306 const array_ty = self.typeOf(bin_op.lhs);
3292 const array_ty_ref = try self.resolveType(array_ty, .direct);
3293 const elem_ty = array_ty.childType(mod);3307 const elem_ty = array_ty.childType(mod);
3294 const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
3295 const array_id = try self.resolve(bin_op.lhs);3308 const array_id = try self.resolve(bin_op.lhs);
3296 const index_id = try self.resolve(bin_op.rhs);3309 const index_id = try self.resolve(bin_op.rhs);
32973310
...@@ -3299,22 +3312,12 @@ const DeclGen = struct {...@@ -3299,22 +3312,12 @@ const DeclGen = struct {
3299 // For now, just generate a temporary and use that.3312 // For now, just generate a temporary and use that.
3300 // TODO: This backend probably also should use isByRef from llvm...3313 // TODO: This backend probably also should use isByRef from llvm...
33013314
3302 const array_ptr_ty_ref = try self.spv.ptrType(array_ty_ref, .Function);3315 const elem_ptr_ty_ref = try self.ptrType(elem_ty, .Function);
3303 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, .Function);
3304
3305 const tmp_id = self.spv.allocId();
3306 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3307 .id_result_type = self.typeId(array_ptr_ty_ref),
3308 .id_result = tmp_id,
3309 .storage_class = .Function,
3310 });
3311 try self.func.body.emit(self.spv.gpa, .OpStore, .{
3312 .pointer = tmp_id,
3313 .object = array_id,
3314 });
33153316
3317 const tmp_id = try self.alloc(array_ty, .{ .storage_class = .Function });
3318 try self.store(array_ty, tmp_id, array_id, .{});
3316 const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id});3319 const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id});
3317 return try self.load(elem_ty, elem_ptr_id, false);3320 return try self.load(elem_ty, elem_ptr_id, .{});
3318 }3321 }
33193322
3320 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3323 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3327,7 +3330,7 @@ const DeclGen = struct {...@@ -3327,7 +3330,7 @@ const DeclGen = struct {
3327 const ptr_id = try self.resolve(bin_op.lhs);3330 const ptr_id = try self.resolve(bin_op.lhs);
3328 const index_id = try self.resolve(bin_op.rhs);3331 const index_id = try self.resolve(bin_op.rhs);
3329 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);3332 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
3330 return try self.load(elem_ty, elem_ptr_id, ptr_ty.isVolatilePtr(mod));3333 return try self.load(elem_ty, elem_ptr_id, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3331 }3334 }
33323335
3333 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {3336 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3335,22 +3338,21 @@ const DeclGen = struct {...@@ -3335,22 +3338,21 @@ const DeclGen = struct {
3335 const bin_op = self.air.instructions.items(.data)[inst].bin_op;3338 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
3336 const un_ptr_ty = self.typeOf(bin_op.lhs);3339 const un_ptr_ty = self.typeOf(bin_op.lhs);
3337 const un_ty = un_ptr_ty.childType(mod);3340 const un_ty = un_ptr_ty.childType(mod);
3338 const layout = self.unionLayout(un_ty, null);3341 const layout = self.unionLayout(un_ty);
33393342
3340 if (layout.tag_size == 0) return;3343 if (layout.tag_size == 0) return;
33413344
3342 const tag_ty = un_ty.unionTagTypeSafety(mod).?;3345 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
3343 const tag_ty_ref = try self.resolveType(tag_ty, .indirect);3346 const tag_ptr_ty_ref = try self.ptrType(tag_ty, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
3344 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
33453347
3346 const union_ptr_id = try self.resolve(bin_op.lhs);3348 const union_ptr_id = try self.resolve(bin_op.lhs);
3347 const new_tag_id = try self.resolve(bin_op.rhs);3349 const new_tag_id = try self.resolve(bin_op.rhs);
33483350
3349 if (layout.payload_size == 0) {3351 if (!layout.has_payload) {
3350 try self.store(tag_ty, union_ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));3352 try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
3351 } else {3353 } else {
3352 const ptr_id = try self.accessChain(tag_ptr_ty_ref, union_ptr_id, &.{layout.tag_index});3354 const ptr_id = try self.accessChain(tag_ptr_ty_ref, union_ptr_id, &.{layout.tag_index});
3353 try self.store(tag_ty, ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));3355 try self.store(tag_ty, ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
3354 }3356 }
3355 }3357 }
33563358
...@@ -3361,11 +3363,11 @@ const DeclGen = struct {...@@ -3361,11 +3363,11 @@ const DeclGen = struct {
3361 const un_ty = self.typeOf(ty_op.operand);3363 const un_ty = self.typeOf(ty_op.operand);
33623364
3363 const mod = self.module;3365 const mod = self.module;
3364 const layout = self.unionLayout(un_ty, null);3366 const layout = self.unionLayout(un_ty);
3365 if (layout.tag_size == 0) return null;3367 if (layout.tag_size == 0) return null;
33663368
3367 const union_handle = try self.resolve(ty_op.operand);3369 const union_handle = try self.resolve(ty_op.operand);
3368 if (layout.payload_size == 0) return union_handle;3370 if (!layout.has_payload) return union_handle;
33693371
3370 const tag_ty = un_ty.unionTagTypeSafety(mod).?;3372 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
3371 return try self.extractField(tag_ty, union_handle, layout.tag_index);3373 return try self.extractField(tag_ty, union_handle, layout.tag_index);
...@@ -3378,8 +3380,8 @@ const DeclGen = struct {...@@ -3378,8 +3380,8 @@ const DeclGen = struct {
3378 payload: ?IdRef,3380 payload: ?IdRef,
3379 ) !IdRef {3381 ) !IdRef {
3380 // To initialize a union, generate a temporary variable with the3382 // To initialize a union, generate a temporary variable with the
3381 // type that has the right field active, then pointer-cast and store3383 // union type, then get the field pointer and pointer-cast it to the
3382 // the active field, and finally load and return the entire union.3384 // right type to store it. Finally load the entire union.
33833385
3384 const mod = self.module;3386 const mod = self.module;
3385 const ip = &mod.intern_pool;3387 const ip = &mod.intern_pool;
...@@ -3390,7 +3392,7 @@ const DeclGen = struct {...@@ -3390,7 +3392,7 @@ const DeclGen = struct {
3390 }3392 }
33913393
3392 const maybe_tag_ty = ty.unionTagTypeSafety(mod);3394 const maybe_tag_ty = ty.unionTagTypeSafety(mod);
3393 const layout = self.unionLayout(ty, active_field);3395 const layout = self.unionLayout(ty);
33943396
3395 const tag_int = if (layout.tag_size != 0) blk: {3397 const tag_int = if (layout.tag_size != 0) blk: {
3396 const tag_ty = maybe_tag_ty.?;3398 const tag_ty = maybe_tag_ty.?;
...@@ -3401,42 +3403,34 @@ const DeclGen = struct {...@@ -3401,42 +3403,34 @@ const DeclGen = struct {
3401 break :blk tag_int_val.toUnsignedInt(mod);3403 break :blk tag_int_val.toUnsignedInt(mod);
3402 } else 0;3404 } else 0;
34033405
3404 if (layout.payload_size == 0) {3406 if (!layout.has_payload) {
3405 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);3407 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
3406 return try self.constInt(tag_ty_ref, tag_int);3408 return try self.constInt(tag_ty_ref, tag_int);
3407 }3409 }
34083410
3409 const un_active_ty_ref = try self.resolveUnionType(ty, active_field);3411 const tmp_id = try self.alloc(ty, .{ .storage_class = .Function });
3410 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, .Function);
3411 const un_general_ty_ref = try self.resolveType(ty, .direct);
3412 const un_general_ptr_ty_ref = try self.spv.ptrType(un_general_ty_ref, .Function);
3413
3414 const tmp_id = self.spv.allocId();
3415 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3416 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3417 .id_result = tmp_id,
3418 .storage_class = .Function,
3419 });
34203412
3421 if (layout.tag_size != 0) {3413 if (layout.tag_size != 0) {
3422 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);3414 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
3423 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, .Function);3415 const tag_ptr_ty_ref = try self.ptrType(maybe_tag_ty.?, .Function);
3424 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});3416 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});
3425 const tag_id = try self.constInt(tag_ty_ref, tag_int);3417 const tag_id = try self.constInt(tag_ty_ref, tag_int);
3426 try self.func.body.emit(self.spv.gpa, .OpStore, .{3418 try self.store(maybe_tag_ty.?, ptr_id, tag_id, .{});
3427 .pointer = ptr_id,
3428 .object = tag_id,
3429 });
3430 }3419 }
34313420
3432 if (layout.active_field_size != 0) {3421 const payload_ty = union_ty.field_types.get(ip)[active_field].toType();
3433 const active_field_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);3422 if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3434 const active_field_ptr_ty_ref = try self.spv.ptrType(active_field_ty_ref, .Function);3423 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3435 const ptr_id = try self.accessChain(active_field_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.active_field_index))});3424 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3436 try self.func.body.emit(self.spv.gpa, .OpStore, .{3425 const active_pl_ptr_ty_ref = try self.ptrType(payload_ty, .Function);
3437 .pointer = ptr_id,3426 const active_pl_ptr_id = self.spv.allocId();
3438 .object = payload.?,3427 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3428 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3429 .id_result = active_pl_ptr_id,
3430 .operand = pl_ptr_id,
3439 });3431 });
3432
3433 try self.store(payload_ty, active_pl_ptr_id, payload.?, .{});
3440 } else {3434 } else {
3441 assert(payload == null);3435 assert(payload == null);
3442 }3436 }
...@@ -3444,34 +3438,21 @@ const DeclGen = struct {...@@ -3444,34 +3438,21 @@ const DeclGen = struct {
3444 // Just leave the padding fields uninitialized...3438 // Just leave the padding fields uninitialized...
3445 // TODO: Or should we initialize them with undef explicitly?3439 // TODO: Or should we initialize them with undef explicitly?
34463440
3447 // Now cast the pointer and load it as the 'generic' union type.3441 return try self.load(ty, tmp_id, .{});
3448
3449 const casted_var_id = self.spv.allocId();
3450 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3451 .id_result_type = self.typeId(un_general_ptr_ty_ref),
3452 .id_result = casted_var_id,
3453 .operand = tmp_id,
3454 });
3455
3456 const result_id = self.spv.allocId();
3457 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
3458 .id_result_type = self.typeId(un_general_ty_ref),
3459 .id_result = result_id,
3460 .pointer = casted_var_id,
3461 });
3462
3463 return result_id;
3464 }3442 }
34653443
3466 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3444 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
3467 if (self.liveness.isUnused(inst)) return null;3445 if (self.liveness.isUnused(inst)) return null;
34683446
3447 const mod = self.module;
3448 const ip = &mod.intern_pool;
3469 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;3449 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
3470 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;3450 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
3471 const ty = self.typeOfIndex(inst);3451 const ty = self.typeOfIndex(inst);
3472 const layout = self.unionLayout(ty, extra.field_index);
34733452
3474 const payload = if (layout.active_field_size != 0)3453 const union_obj = mod.typeToUnion(ty).?;
3454 const field_ty = union_obj.field_types.get(ip)[extra.field_index].toType();
3455 const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(mod))
3475 try self.resolve(extra.init)3456 try self.resolve(extra.init)
3476 else3457 else
3477 null;3458 null;
...@@ -3500,30 +3481,24 @@ const DeclGen = struct {...@@ -3500,30 +3481,24 @@ const DeclGen = struct {
3500 .Union => switch (object_ty.containerLayout(mod)) {3481 .Union => switch (object_ty.containerLayout(mod)) {
3501 .Packed => unreachable, // TODO3482 .Packed => unreachable, // TODO
3502 else => {3483 else => {
3503 // Store, pointer-cast, load3484 // Store, ptr-elem-ptr, pointer-cast, load
3504 const un_general_ty_ref = try self.resolveType(object_ty, .indirect);3485 const layout = self.unionLayout(object_ty);
3505 const un_general_ptr_ty_ref = try self.spv.ptrType(un_general_ty_ref, .Function);3486 assert(layout.has_payload);
3506 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);3487
3507 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, .Function);3488 const tmp_id = try self.alloc(object_ty, .{ .storage_class = .Function });
3508 const field_ty_ref = try self.resolveType(field_ty, .indirect);3489 try self.store(object_ty, tmp_id, object_id, .{});
3509 const field_ptr_ty_ref = try self.spv.ptrType(field_ty_ref, .Function);3490
35103491 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3511 const tmp_id = self.spv.allocId();3492 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3512 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{3493
3513 .id_result_type = self.typeId(un_general_ptr_ty_ref),3494 const active_pl_ptr_ty_ref = try self.ptrType(field_ty, .Function);
3514 .id_result = tmp_id,3495 const active_pl_ptr_id = self.spv.allocId();
3515 .storage_class = .Function,
3516 });
3517 try self.store(object_ty, tmp_id, object_id, false);
3518 const casted_tmp_id = self.spv.allocId();
3519 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{3496 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3520 .id_result_type = self.typeId(un_active_ptr_ty_ref),3497 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3521 .id_result = casted_tmp_id,3498 .id_result = active_pl_ptr_id,
3522 .operand = tmp_id,3499 .operand = pl_ptr_id,
3523 });3500 });
3524 const layout = self.unionLayout(object_ty, field_index);3501 return try self.load(field_ty, active_pl_ptr_id, .{});
3525 const field_ptr_id = try self.accessChain(field_ptr_ty_ref, casted_tmp_id, &.{layout.active_field_index});
3526 return try self.load(field_ty, field_ptr_id, false);
3527 },3502 },
3528 },3503 },
3529 else => unreachable,3504 else => unreachable,
...@@ -3582,18 +3557,24 @@ const DeclGen = struct {...@@ -3582,18 +3557,24 @@ const DeclGen = struct {
3582 .Union => switch (object_ty.containerLayout(mod)) {3557 .Union => switch (object_ty.containerLayout(mod)) {
3583 .Packed => unreachable, // TODO3558 .Packed => unreachable, // TODO
3584 else => {3559 else => {
3560 const layout = self.unionLayout(object_ty);
3561 if (!layout.has_payload) {
3562 // Asked to get a pointer to a zero-sized field. Just lower this
3563 // to undefined, there is no reason to make it be a valid pointer.
3564 return try self.spv.constUndef(result_ty_ref);
3565 }
3566
3585 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));3567 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));
3586 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);3568 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, storage_class);
3587 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, storage_class);3569 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, object_ptr, &.{layout.payload_index});
35883570
3589 const casted_id = self.spv.allocId();3571 const active_pl_ptr_id = self.spv.allocId();
3590 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{3572 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3591 .id_result_type = self.typeId(un_active_ptr_ty_ref),3573 .id_result_type = self.typeId(result_ty_ref),
3592 .id_result = casted_id,3574 .id_result = active_pl_ptr_id,
3593 .operand = object_ptr,3575 .operand = pl_ptr_id,
3594 });3576 });
3595 const layout = self.unionLayout(object_ty, field_index);3577 return active_pl_ptr_id;
3596 return try self.accessChain(result_ty_ref, casted_id, &.{layout.active_field_index});
3597 },3578 },
3598 },3579 },
3599 else => unreachable,3580 else => unreachable,
...@@ -3609,23 +3590,13 @@ const DeclGen = struct {...@@ -3609,23 +3590,13 @@ const DeclGen = struct {
3609 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);3590 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);
3610 }3591 }
36113592
3612 /// We cannot use an OpVariable directly in an OpSpecConstantOp, but we can3593 const AllocOptions = struct {
3613 /// after we insert a dummy AccessChain...3594 initializer: ?IdRef = null,
3614 /// TODO: Get rid of this3595 /// The final storage class of the pointer. This may be either `.Generic` or `.Function`.
3615 fn makePointerConstant(3596 /// In either case, the local is allocated in the `.Function` storage class, and optionally
3616 self: *DeclGen,3597 /// cast back to `.Generic`.
3617 section: *SpvSection,3598 storage_class: StorageClass = .Generic,
3618 ptr_ty_ref: CacheRef,3599 };
3619 ptr_id: IdRef,
3620 ) !IdRef {
3621 const result_id = self.spv.allocId();
3622 try section.emitSpecConstantOp(self.spv.gpa, .OpInBoundsAccessChain, .{
3623 .id_result_type = self.typeId(ptr_ty_ref),
3624 .id_result = result_id,
3625 .base = ptr_id,
3626 });
3627 return result_id;
3628 }
36293600
3630 // Allocate a function-local variable, with possible initializer.3601 // Allocate a function-local variable, with possible initializer.
3631 // This function returns a pointer to a variable of type `ty_ref`,3602 // This function returns a pointer to a variable of type `ty_ref`,
...@@ -3633,30 +3604,36 @@ const DeclGen = struct {...@@ -3633,30 +3604,36 @@ const DeclGen = struct {
3633 // placed in the Function address space.3604 // placed in the Function address space.
3634 fn alloc(3605 fn alloc(
3635 self: *DeclGen,3606 self: *DeclGen,
3636 ty_ref: CacheRef,3607 ty: Type,
3637 initializer: ?IdRef,3608 options: AllocOptions,
3638 ) !IdRef {3609 ) !IdRef {
3639 const fn_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Function);3610 const ptr_fn_ty_ref = try self.ptrType(ty, .Function);
3640 const general_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Generic);
36413611
3642 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to3612 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
3643 // directly generate them into func.prologue instead of the body.3613 // directly generate them into func.prologue instead of the body.
3644 const var_id = self.spv.allocId();3614 const var_id = self.spv.allocId();
3645 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{3615 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3646 .id_result_type = self.typeId(fn_ptr_ty_ref),3616 .id_result_type = self.typeId(ptr_fn_ty_ref),
3647 .id_result = var_id,3617 .id_result = var_id,
3648 .storage_class = .Function,3618 .storage_class = .Function,
3649 .initializer = initializer,3619 .initializer = options.initializer,
3650 });3620 });
36513621
3652 // Convert to a generic pointer3622 switch (options.storage_class) {
3653 const result_id = self.spv.allocId();3623 .Generic => {
3654 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{3624 const ptr_gn_ty_ref = try self.ptrType(ty, .Generic);
3655 .id_result_type = self.typeId(general_ptr_ty_ref),3625 // Convert to a generic pointer
3656 .id_result = result_id,3626 const result_id = self.spv.allocId();
3657 .pointer = var_id,3627 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
3658 });3628 .id_result_type = self.typeId(ptr_gn_ty_ref),
3659 return result_id;3629 .id_result = result_id,
3630 .pointer = var_id,
3631 });
3632 return result_id;
3633 },
3634 .Function => return var_id,
3635 else => unreachable,
3636 }
3660 }3637 }
36613638
3662 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3639 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3665,8 +3642,7 @@ const DeclGen = struct {...@@ -3665,8 +3642,7 @@ const DeclGen = struct {
3665 const ptr_ty = self.typeOfIndex(inst);3642 const ptr_ty = self.typeOfIndex(inst);
3666 assert(ptr_ty.ptrAddressSpace(mod) == .generic);3643 assert(ptr_ty.ptrAddressSpace(mod) == .generic);
3667 const child_ty = ptr_ty.childType(mod);3644 const child_ty = ptr_ty.childType(mod);
3668 const child_ty_ref = try self.resolveType(child_ty, .indirect);3645 return try self.alloc(child_ty, .{});
3669 return try self.alloc(child_ty_ref, null);
3670 }3646 }
36713647
3672 fn airArg(self: *DeclGen) IdRef {3648 fn airArg(self: *DeclGen) IdRef {
...@@ -3781,7 +3757,7 @@ const DeclGen = struct {...@@ -3781,7 +3757,7 @@ const DeclGen = struct {
3781 const operand = try self.resolve(ty_op.operand);3757 const operand = try self.resolve(ty_op.operand);
3782 if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;3758 if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
37833759
3784 return try self.load(elem_ty, operand, ptr_ty.isVolatilePtr(mod));3760 return try self.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3785 }3761 }
37863762
3787 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {3763 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3791,7 +3767,7 @@ const DeclGen = struct {...@@ -3791,7 +3767,7 @@ const DeclGen = struct {
3791 const ptr = try self.resolve(bin_op.lhs);3767 const ptr = try self.resolve(bin_op.lhs);
3792 const value = try self.resolve(bin_op.rhs);3768 const value = try self.resolve(bin_op.rhs);
37933769
3794 try self.store(elem_ty, ptr, value, ptr_ty.isVolatilePtr(self.module));3770 try self.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(self.module) });
3795 }3771 }
37963772
3797 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {3773 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3855,7 +3831,7 @@ const DeclGen = struct {...@@ -3855,7 +3831,7 @@ const DeclGen = struct {
3855 }3831 }
38563832
3857 const ptr = try self.resolve(un_op);3833 const ptr = try self.resolve(un_op);
3858 const value = try self.load(ret_ty, ptr, ptr_ty.isVolatilePtr(mod));3834 const value = try self.load(ret_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3859 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{3835 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{
3860 .value = value,3836 .value = value,
3861 });3837 });
...@@ -3981,8 +3957,11 @@ const DeclGen = struct {...@@ -3981,8 +3957,11 @@ const DeclGen = struct {
3981 members[eu_layout.errorFieldIndex()] = operand_id;3957 members[eu_layout.errorFieldIndex()] = operand_id;
3982 members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref);3958 members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref);
39833959
3984 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);3960 var types: [2]Type = undefined;
3985 return try self.constructStruct(err_union_ty_ref, &members);3961 types[eu_layout.errorFieldIndex()] = Type.anyerror;
3962 types[eu_layout.payloadFieldIndex()] = payload_ty;
3963
3964 return try self.constructStruct(err_union_ty, &types, &members);
3986 }3965 }
39873966
3988 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3967 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -4003,8 +3982,11 @@ const DeclGen = struct {...@@ -4003,8 +3982,11 @@ const DeclGen = struct {
4003 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);3982 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);
4004 members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id);3983 members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id);
40053984
4006 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);3985 var types: [2]Type = undefined;
4007 return try self.constructStruct(err_union_ty_ref, &members);3986 types[eu_layout.errorFieldIndex()] = Type.anyerror;
3987 types[eu_layout.payloadFieldIndex()] = payload_ty;
3988
3989 return try self.constructStruct(err_union_ty, &types, &members);
4008 }3990 }
40093991
4010 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {3992 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
...@@ -4038,7 +4020,7 @@ const DeclGen = struct {...@@ -4038,7 +4020,7 @@ const DeclGen = struct {
4038 .is_null => .eq,4020 .is_null => .eq,
4039 .is_non_null => .neq,4021 .is_non_null => .neq,
4040 };4022 };
4041 return try self.cmp(op, ptr_ty, ptr_id, null_id);4023 return try self.cmp(op, Type.bool, ptr_ty, ptr_id, null_id);
4042 }4024 }
40434025
4044 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))4026 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
...@@ -4136,10 +4118,10 @@ const DeclGen = struct {...@@ -4136,10 +4118,10 @@ const DeclGen = struct {
4136 return operand_id;4118 return operand_id;
4137 }4119 }
41384120
4139 const optional_ty_ref = try self.resolveType(optional_ty, .direct);
4140 const payload_id = try self.convertToIndirect(payload_ty, operand_id);4121 const payload_id = try self.convertToIndirect(payload_ty, operand_id);
4141 const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };4122 const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };
4142 return try self.constructStruct(optional_ty_ref, &members);4123 const types = [_]Type{ payload_ty, Type.bool };
4124 return try self.constructStruct(optional_ty, &types, &members);
4143 }4125 }
41444126
4145 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {4127 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -4421,6 +4403,7 @@ const DeclGen = struct {...@@ -4421,6 +4403,7 @@ const DeclGen = struct {
4421 }4403 }
44224404
4423 // TODO: Multiple results4405 // TODO: Multiple results
4406 // TODO: Check that the output type from assembly is the same as the type actually expected by Zig.
4424 }4407 }
44254408
4426 return null;4409 return null;
src/codegen/spirv/Assembler.zig+10-4
...@@ -304,10 +304,16 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {...@@ -304,10 +304,16 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {
304 // and so some consideration must be taken when entering this in the type system.304 // and so some consideration must be taken when entering this in the type system.
305 return self.todo("process OpTypeArray", .{});305 return self.todo("process OpTypeArray", .{});
306 },306 },
307 .OpTypePointer => try self.spv.ptrType(307 .OpTypePointer => blk: {
308 try self.resolveTypeRef(operands[2].ref_id),308 break :blk try self.spv.resolve(.{
309 @as(spec.StorageClass, @enumFromInt(operands[1].value)),309 .ptr_type = .{
310 ),310 .storage_class = @enumFromInt(operands[1].value),
311 .child_type = try self.resolveTypeRef(operands[2].ref_id),
312 // TODO: This should be a proper reference resolved via OpTypeForwardPointer
313 .fwd = @enumFromInt(std.math.maxInt(u32)),
314 },
315 });
316 },
311 .OpTypeFunction => blk: {317 .OpTypeFunction => blk: {
312 const param_operands = operands[2..];318 const param_operands = operands[2..];
313 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);319 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);
src/codegen/spirv/Cache.zig+182-124
...@@ -22,6 +22,8 @@ const Opcode = spec.Opcode;...@@ -22,6 +22,8 @@ const Opcode = spec.Opcode;
22const IdResult = spec.IdResult;22const IdResult = spec.IdResult;
23const StorageClass = spec.StorageClass;23const StorageClass = spec.StorageClass;
2424
25const InternPool = @import("../../InternPool.zig");
26
25const Self = @This();27const Self = @This();
2628
27map: std.AutoArrayHashMapUnmanaged(void, void) = .{},29map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
...@@ -31,6 +33,8 @@ extra: std.ArrayListUnmanaged(u32) = .{},...@@ -31,6 +33,8 @@ extra: std.ArrayListUnmanaged(u32) = .{},
31string_bytes: std.ArrayListUnmanaged(u8) = .{},33string_bytes: std.ArrayListUnmanaged(u8) = .{},
32strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},34strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},
3335
36recursive_ptrs: std.AutoHashMapUnmanaged(Ref, void) = .{},
37
34const Item = struct {38const Item = struct {
35 tag: Tag,39 tag: Tag,
36 /// The result-id that this item uses.40 /// The result-id that this item uses.
...@@ -62,18 +66,21 @@ const Tag = enum {...@@ -62,18 +66,21 @@ const Tag = enum {
62 /// Function (proto)type66 /// Function (proto)type
63 /// data is payload to FunctionType67 /// data is payload to FunctionType
64 type_function,68 type_function,
65 /// Pointer type in the CrossWorkgroup storage class69 // /// Pointer type in the CrossWorkgroup storage class
66 /// data is child type70 // /// data is child type
67 type_ptr_generic,71 // type_ptr_generic,
68 /// Pointer type in the CrossWorkgroup storage class72 // /// Pointer type in the CrossWorkgroup storage class
69 /// data is child type73 // /// data is child type
70 type_ptr_crosswgp,74 // type_ptr_crosswgp,
71 /// Pointer type in the Function storage class75 // /// Pointer type in the Function storage class
72 /// data is child type76 // /// data is child type
73 type_ptr_function,77 // type_ptr_function,
74 /// Simple pointer type that does not have any decorations.78 /// Simple pointer type that does not have any decorations.
75 /// data is payload to SimplePointerType79 /// data is payload to SimplePointerType
76 type_ptr_simple,80 type_ptr_simple,
81 /// A forward declaration for a pointer.
82 /// data is ForwardPointerType
83 type_fwd_ptr,
77 /// Simple structure type that does not have any decorations.84 /// Simple structure type that does not have any decorations.
78 /// data is payload to SimpleStructType85 /// data is payload to SimpleStructType
79 type_struct_simple,86 type_struct_simple,
...@@ -142,6 +149,12 @@ const Tag = enum {...@@ -142,6 +149,12 @@ const Tag = enum {
142 const SimplePointerType = struct {149 const SimplePointerType = struct {
143 storage_class: StorageClass,150 storage_class: StorageClass,
144 child_type: Ref,151 child_type: Ref,
152 fwd: Ref,
153 };
154
155 const ForwardPointerType = struct {
156 storage_class: StorageClass,
157 zig_child_type: InternPool.Index,
145 };158 };
146159
147 /// Trailing:160 /// Trailing:
...@@ -163,14 +176,14 @@ const Tag = enum {...@@ -163,14 +176,14 @@ const Tag = enum {
163 fn encode(value: f64) Float64 {176 fn encode(value: f64) Float64 {
164 const bits = @as(u64, @bitCast(value));177 const bits = @as(u64, @bitCast(value));
165 return .{178 return .{
166 .low = @as(u32, @truncate(bits)),179 .low = @truncate(bits),
167 .high = @as(u32, @truncate(bits >> 32)),180 .high = @truncate(bits >> 32),
168 };181 };
169 }182 }
170183
171 fn decode(self: Float64) f64 {184 fn decode(self: Float64) f64 {
172 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);185 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);
173 return @as(f64, @bitCast(bits));186 return @bitCast(bits);
174 }187 }
175 };188 };
176189
...@@ -192,8 +205,8 @@ const Tag = enum {...@@ -192,8 +205,8 @@ const Tag = enum {
192 fn encode(ty: Ref, value: u64) Int64 {205 fn encode(ty: Ref, value: u64) Int64 {
193 return .{206 return .{
194 .ty = ty,207 .ty = ty,
195 .low = @as(u32, @truncate(value)),208 .low = @truncate(value),
196 .high = @as(u32, @truncate(value >> 32)),209 .high = @truncate(value >> 32),
197 };210 };
198 }211 }
199212
...@@ -210,8 +223,8 @@ const Tag = enum {...@@ -210,8 +223,8 @@ const Tag = enum {
210 fn encode(ty: Ref, value: i64) Int64 {223 fn encode(ty: Ref, value: i64) Int64 {
211 return .{224 return .{
212 .ty = ty,225 .ty = ty,
213 .low = @as(u32, @truncate(@as(u64, @bitCast(value)))),226 .low = @truncate(@as(u64, @bitCast(value))),
214 .high = @as(u32, @truncate(@as(u64, @bitCast(value)) >> 32)),227 .high = @truncate(@as(u64, @bitCast(value)) >> 32),
215 };228 };
216 }229 }
217230
...@@ -237,6 +250,7 @@ pub const Key = union(enum) {...@@ -237,6 +250,7 @@ pub const Key = union(enum) {
237 array_type: ArrayType,250 array_type: ArrayType,
238 function_type: FunctionType,251 function_type: FunctionType,
239 ptr_type: PointerType,252 ptr_type: PointerType,
253 fwd_ptr_type: ForwardPointerType,
240 struct_type: StructType,254 struct_type: StructType,
241 opaque_type: OpaqueType,255 opaque_type: OpaqueType,
242256
...@@ -273,12 +287,18 @@ pub const Key = union(enum) {...@@ -273,12 +287,18 @@ pub const Key = union(enum) {
273 pub const PointerType = struct {287 pub const PointerType = struct {
274 storage_class: StorageClass,288 storage_class: StorageClass,
275 child_type: Ref,289 child_type: Ref,
290 fwd: Ref,
276 // TODO: Decorations:291 // TODO: Decorations:
277 // - Alignment292 // - Alignment
278 // - ArrayStride,293 // - ArrayStride,
279 // - MaxByteOffset,294 // - MaxByteOffset,
280 };295 };
281296
297 pub const ForwardPointerType = struct {
298 zig_child_type: InternPool.Index,
299 storage_class: StorageClass,
300 };
301
282 pub const StructType = struct {302 pub const StructType = struct {
283 // TODO: Decorations.303 // TODO: Decorations.
284 /// The name of the structure. Can be `.none`.304 /// The name of the structure. Can be `.none`.
...@@ -313,21 +333,21 @@ pub const Key = union(enum) {...@@ -313,21 +333,21 @@ pub const Key = union(enum) {
313 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.333 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.
314 fn toBits32(self: Int) u32 {334 fn toBits32(self: Int) u32 {
315 return switch (self.value) {335 return switch (self.value) {
316 .uint64 => |val| @as(u32, @intCast(val)),336 .uint64 => |val| @intCast(val),
317 .int64 => |val| if (val < 0) @as(u32, @bitCast(@as(i32, @intCast(val)))) else @as(u32, @intCast(val)),337 .int64 => |val| if (val < 0) @bitCast(@as(i32, @intCast(val))) else @intCast(val),
318 };338 };
319 }339 }
320340
321 fn toBits64(self: Int) u64 {341 fn toBits64(self: Int) u64 {
322 return switch (self.value) {342 return switch (self.value) {
323 .uint64 => |val| val,343 .uint64 => |val| val,
324 .int64 => |val| @as(u64, @bitCast(val)),344 .int64 => |val| @bitCast(val),
325 };345 };
326 }346 }
327347
328 fn to(self: Int, comptime T: type) T {348 fn to(self: Int, comptime T: type) T {
329 return switch (self.value) {349 return switch (self.value) {
330 inline else => |val| @as(T, @intCast(val)),350 inline else => |val| @intCast(val),
331 };351 };
332 }352 }
333 };353 };
...@@ -387,7 +407,7 @@ pub const Key = union(enum) {...@@ -387,7 +407,7 @@ pub const Key = union(enum) {
387 },407 },
388 inline else => |key| std.hash.autoHash(&hasher, key),408 inline else => |key| std.hash.autoHash(&hasher, key),
389 }409 }
390 return @as(u32, @truncate(hasher.final()));410 return @truncate(hasher.final());
391 }411 }
392412
393 fn eql(a: Key, b: Key) bool {413 fn eql(a: Key, b: Key) bool {
...@@ -419,7 +439,7 @@ pub const Key = union(enum) {...@@ -419,7 +439,7 @@ pub const Key = union(enum) {
419439
420 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {440 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {
421 _ = b_void;441 _ = b_void;
422 return ctx.self.lookup(@as(Ref, @enumFromInt(b_index))).eql(a);442 return ctx.self.lookup(@enumFromInt(b_index)).eql(a);
423 }443 }
424444
425 pub fn hash(ctx: @This(), a: Key) u32 {445 pub fn hash(ctx: @This(), a: Key) u32 {
...@@ -450,6 +470,7 @@ pub fn deinit(self: *Self, spv: *const Module) void {...@@ -450,6 +470,7 @@ pub fn deinit(self: *Self, spv: *const Module) void {
450 self.extra.deinit(spv.gpa);470 self.extra.deinit(spv.gpa);
451 self.string_bytes.deinit(spv.gpa);471 self.string_bytes.deinit(spv.gpa);
452 self.strings.deinit(spv.gpa);472 self.strings.deinit(spv.gpa);
473 self.recursive_ptrs.deinit(spv.gpa);
453}474}
454475
455/// Actually materialize the database into spir-v instructions.476/// Actually materialize the database into spir-v instructions.
...@@ -460,7 +481,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {...@@ -460,7 +481,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {
460 var section = Section{};481 var section = Section{};
461 errdefer section.deinit(spv.gpa);482 errdefer section.deinit(spv.gpa);
462 for (self.items.items(.result_id), 0..) |result_id, index| {483 for (self.items.items(.result_id), 0..) |result_id, index| {
463 try self.emit(spv, result_id, @as(Ref, @enumFromInt(index)), &section);484 try self.emit(spv, result_id, @enumFromInt(index), &section);
464 }485 }
465 return section;486 return section;
466}487}
...@@ -538,6 +559,15 @@ fn emit(...@@ -538,6 +559,15 @@ fn emit(
538 });559 });
539 // TODO: Decorations?560 // TODO: Decorations?
540 },561 },
562 .fwd_ptr_type => |fwd| {
563 // Only emit the OpTypeForwardPointer if its actually required.
564 if (self.recursive_ptrs.contains(ref)) {
565 try section.emit(spv.gpa, .OpTypeForwardPointer, .{
566 .pointer_type = result_id,
567 .storage_class = fwd.storage_class,
568 });
569 }
570 },
541 .struct_type => |struct_type| {571 .struct_type => |struct_type| {
542 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);572 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);
543 section.writeOperand(IdResult, result_id);573 section.writeOperand(IdResult, result_id);
...@@ -549,7 +579,7 @@ fn emit(...@@ -549,7 +579,7 @@ fn emit(
549 }579 }
550 for (struct_type.memberNames(), 0..) |member_name, i| {580 for (struct_type.memberNames(), 0..) |member_name, i| {
551 if (self.getString(member_name)) |name| {581 if (self.getString(member_name)) |name| {
552 try spv.memberDebugName(result_id, @as(u32, @intCast(i)), name);582 try spv.memberDebugName(result_id, @intCast(i), name);
553 }583 }
554 }584 }
555 // TODO: Decorations?585 // TODO: Decorations?
...@@ -625,13 +655,12 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -625,13 +655,12 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
625 const adapter: Key.Adapter = .{ .self = self };655 const adapter: Key.Adapter = .{ .self = self };
626 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);656 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);
627 if (entry.found_existing) {657 if (entry.found_existing) {
628 return @as(Ref, @enumFromInt(entry.index));658 return @enumFromInt(entry.index);
629 }659 }
630 const result_id = spv.allocId();
631 const item: Item = switch (key) {660 const item: Item = switch (key) {
632 inline .void_type, .bool_type => .{661 inline .void_type, .bool_type => .{
633 .tag = .type_simple,662 .tag = .type_simple,
634 .result_id = result_id,663 .result_id = spv.allocId(),
635 .data = @intFromEnum(key.toSimpleType()),664 .data = @intFromEnum(key.toSimpleType()),
636 },665 },
637 .int_type => |int| blk: {666 .int_type => |int| blk: {
...@@ -641,87 +670,104 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -641,87 +670,104 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
641 };670 };
642 break :blk .{671 break :blk .{
643 .tag = t,672 .tag = t,
644 .result_id = result_id,673 .result_id = spv.allocId(),
645 .data = int.bits,674 .data = int.bits,
646 };675 };
647 },676 },
648 .float_type => |float| .{677 .float_type => |float| .{
649 .tag = .type_float,678 .tag = .type_float,
650 .result_id = result_id,679 .result_id = spv.allocId(),
651 .data = float.bits,680 .data = float.bits,
652 },681 },
653 .vector_type => |vector| .{682 .vector_type => |vector| .{
654 .tag = .type_vector,683 .tag = .type_vector,
655 .result_id = result_id,684 .result_id = spv.allocId(),
656 .data = try self.addExtra(spv, vector),685 .data = try self.addExtra(spv, vector),
657 },686 },
658 .array_type => |array| .{687 .array_type => |array| .{
659 .tag = .type_array,688 .tag = .type_array,
660 .result_id = result_id,689 .result_id = spv.allocId(),
661 .data = try self.addExtra(spv, array),690 .data = try self.addExtra(spv, array),
662 },691 },
663 .function_type => |function| blk: {692 .function_type => |function| blk: {
664 const extra = try self.addExtra(spv, Tag.FunctionType{693 const extra = try self.addExtra(spv, Tag.FunctionType{
665 .param_len = @as(u32, @intCast(function.parameters.len)),694 .param_len = @intCast(function.parameters.len),
666 .return_type = function.return_type,695 .return_type = function.return_type,
667 });696 });
668 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(function.parameters)));697 try self.extra.appendSlice(spv.gpa, @ptrCast(function.parameters));
669 break :blk .{698 break :blk .{
670 .tag = .type_function,699 .tag = .type_function,
671 .result_id = result_id,700 .result_id = spv.allocId(),
672 .data = extra,701 .data = extra,
673 };702 };
674 },703 },
675 .ptr_type => |ptr| switch (ptr.storage_class) {704 // .ptr_type => |ptr| switch (ptr.storage_class) {
676 .Generic => Item{705 // .Generic => Item{
677 .tag = .type_ptr_generic,706 // .tag = .type_ptr_generic,
678 .result_id = result_id,707 // .result_id = spv.allocId(),
679 .data = @intFromEnum(ptr.child_type),708 // .data = @intFromEnum(ptr.child_type),
680 },709 // },
681 .CrossWorkgroup => Item{710 // .CrossWorkgroup => Item{
682 .tag = .type_ptr_crosswgp,711 // .tag = .type_ptr_crosswgp,
683 .result_id = result_id,712 // .result_id = spv.allocId(),
684 .data = @intFromEnum(ptr.child_type),713 // .data = @intFromEnum(ptr.child_type),
685 },714 // },
686 .Function => Item{715 // .Function => Item{
687 .tag = .type_ptr_function,716 // .tag = .type_ptr_function,
688 .result_id = result_id,717 // .result_id = spv.allocId(),
689 .data = @intFromEnum(ptr.child_type),718 // .data = @intFromEnum(ptr.child_type),
690 },719 // },
691 else => |storage_class| Item{720 // else => |storage_class| Item{
692 .tag = .type_ptr_simple,721 // .tag = .type_ptr_simple,
693 .result_id = result_id,722 // .result_id = spv.allocId(),
694 .data = try self.addExtra(spv, Tag.SimplePointerType{723 // .data = try self.addExtra(spv, Tag.SimplePointerType{
695 .storage_class = storage_class,724 // .storage_class = storage_class,
696 .child_type = ptr.child_type,725 // .child_type = ptr.child_type,
697 }),726 // }),
698 },727 // },
728 // },
729 .ptr_type => |ptr| Item{
730 .tag = .type_ptr_simple,
731 .result_id = self.resultId(ptr.fwd),
732 .data = try self.addExtra(spv, Tag.SimplePointerType{
733 .storage_class = ptr.storage_class,
734 .child_type = ptr.child_type,
735 .fwd = ptr.fwd,
736 }),
737 },
738 .fwd_ptr_type => |fwd| Item{
739 .tag = .type_fwd_ptr,
740 .result_id = spv.allocId(),
741 .data = try self.addExtra(spv, Tag.ForwardPointerType{
742 .zig_child_type = fwd.zig_child_type,
743 .storage_class = fwd.storage_class,
744 }),
699 },745 },
700 .struct_type => |struct_type| blk: {746 .struct_type => |struct_type| blk: {
701 const extra = try self.addExtra(spv, Tag.SimpleStructType{747 const extra = try self.addExtra(spv, Tag.SimpleStructType{
702 .name = struct_type.name,748 .name = struct_type.name,
703 .members_len = @as(u32, @intCast(struct_type.member_types.len)),749 .members_len = @intCast(struct_type.member_types.len),
704 });750 });
705 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(struct_type.member_types)));751 try self.extra.appendSlice(spv.gpa, @ptrCast(struct_type.member_types));
706752
707 if (struct_type.member_names) |member_names| {753 if (struct_type.member_names) |member_names| {
708 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(member_names)));754 try self.extra.appendSlice(spv.gpa, @ptrCast(member_names));
709 break :blk Item{755 break :blk Item{
710 .tag = .type_struct_simple_with_member_names,756 .tag = .type_struct_simple_with_member_names,
711 .result_id = result_id,757 .result_id = spv.allocId(),
712 .data = extra,758 .data = extra,
713 };759 };
714 } else {760 } else {
715 break :blk Item{761 break :blk Item{
716 .tag = .type_struct_simple,762 .tag = .type_struct_simple,
717 .result_id = result_id,763 .result_id = spv.allocId(),
718 .data = extra,764 .data = extra,
719 };765 };
720 }766 }
721 },767 },
722 .opaque_type => |opaque_type| Item{768 .opaque_type => |opaque_type| Item{
723 .tag = .type_opaque,769 .tag = .type_opaque,
724 .result_id = result_id,770 .result_id = spv.allocId(),
725 .data = @intFromEnum(opaque_type.name),771 .data = @intFromEnum(opaque_type.name),
726 },772 },
727 .int => |int| blk: {773 .int => |int| blk: {
...@@ -729,13 +775,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -729,13 +775,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
729 if (int_type.signedness == .unsigned and int_type.bits == 8) {775 if (int_type.signedness == .unsigned and int_type.bits == 8) {
730 break :blk .{776 break :blk .{
731 .tag = .uint8,777 .tag = .uint8,
732 .result_id = result_id,778 .result_id = spv.allocId(),
733 .data = int.to(u8),779 .data = int.to(u8),
734 };780 };
735 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {781 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {
736 break :blk .{782 break :blk .{
737 .tag = .uint32,783 .tag = .uint32,
738 .result_id = result_id,784 .result_id = spv.allocId(),
739 .data = int.to(u32),785 .data = int.to(u32),
740 };786 };
741 }787 }
...@@ -745,32 +791,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -745,32 +791,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
745 if (val >= 0 and val <= std.math.maxInt(u32)) {791 if (val >= 0 and val <= std.math.maxInt(u32)) {
746 break :blk .{792 break :blk .{
747 .tag = .uint_small,793 .tag = .uint_small,
748 .result_id = result_id,794 .result_id = spv.allocId(),
749 .data = try self.addExtra(spv, Tag.UInt32{795 .data = try self.addExtra(spv, Tag.UInt32{
750 .ty = int.ty,796 .ty = int.ty,
751 .value = @as(u32, @intCast(val)),797 .value = @intCast(val),
752 }),798 }),
753 };799 };
754 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {800 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {
755 break :blk .{801 break :blk .{
756 .tag = .int_small,802 .tag = .int_small,
757 .result_id = result_id,803 .result_id = spv.allocId(),
758 .data = try self.addExtra(spv, Tag.Int32{804 .data = try self.addExtra(spv, Tag.Int32{
759 .ty = int.ty,805 .ty = int.ty,
760 .value = @as(i32, @intCast(val)),806 .value = @intCast(val),
761 }),807 }),
762 };808 };
763 } else if (val < 0) {809 } else if (val < 0) {
764 break :blk .{810 break :blk .{
765 .tag = .int_large,811 .tag = .int_large,
766 .result_id = result_id,812 .result_id = spv.allocId(),
767 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @as(i64, @intCast(val)))),813 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @intCast(val))),
768 };814 };
769 } else {815 } else {
770 break :blk .{816 break :blk .{
771 .tag = .uint_large,817 .tag = .uint_large,
772 .result_id = result_id,818 .result_id = spv.allocId(),
773 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @as(u64, @intCast(val)))),819 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @intCast(val))),
774 };820 };
775 }821 }
776 },822 },
...@@ -779,29 +825,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -779,29 +825,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
779 .float => |float| switch (self.lookup(float.ty).float_type.bits) {825 .float => |float| switch (self.lookup(float.ty).float_type.bits) {
780 16 => .{826 16 => .{
781 .tag = .float16,827 .tag = .float16,
782 .result_id = result_id,828 .result_id = spv.allocId(),
783 .data = @as(u16, @bitCast(float.value.float16)),829 .data = @as(u16, @bitCast(float.value.float16)),
784 },830 },
785 32 => .{831 32 => .{
786 .tag = .float32,832 .tag = .float32,
787 .result_id = result_id,833 .result_id = spv.allocId(),
788 .data = @as(u32, @bitCast(float.value.float32)),834 .data = @as(u32, @bitCast(float.value.float32)),
789 },835 },
790 64 => .{836 64 => .{
791 .tag = .float64,837 .tag = .float64,
792 .result_id = result_id,838 .result_id = spv.allocId(),
793 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),839 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),
794 },840 },
795 else => unreachable,841 else => unreachable,
796 },842 },
797 .undef => |undef| .{843 .undef => |undef| .{
798 .tag = .undef,844 .tag = .undef,
799 .result_id = result_id,845 .result_id = spv.allocId(),
800 .data = @intFromEnum(undef.ty),846 .data = @intFromEnum(undef.ty),
801 },847 },
802 .null => |null_info| .{848 .null => |null_info| .{
803 .tag = .null,849 .tag = .null,
804 .result_id = result_id,850 .result_id = spv.allocId(),
805 .data = @intFromEnum(null_info.ty),851 .data = @intFromEnum(null_info.ty),
806 },852 },
807 .bool => |bool_info| .{853 .bool => |bool_info| .{
...@@ -809,13 +855,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -809,13 +855,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
809 true => Tag.bool_true,855 true => Tag.bool_true,
810 false => Tag.bool_false,856 false => Tag.bool_false,
811 },857 },
812 .result_id = result_id,858 .result_id = spv.allocId(),
813 .data = @intFromEnum(bool_info.ty),859 .data = @intFromEnum(bool_info.ty),
814 },860 },
815 };861 };
816 try self.items.append(spv.gpa, item);862 try self.items.append(spv.gpa, item);
817863
818 return @as(Ref, @enumFromInt(entry.index));864 return @enumFromInt(entry.index);
819}865}
820866
821/// Turn a Ref back into a Key.867/// Turn a Ref back into a Key.
...@@ -830,14 +876,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -830,14 +876,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
830 },876 },
831 .type_int_signed => .{ .int_type = .{877 .type_int_signed => .{ .int_type = .{
832 .signedness = .signed,878 .signedness = .signed,
833 .bits = @as(u16, @intCast(data)),879 .bits = @intCast(data),
834 } },880 } },
835 .type_int_unsigned => .{ .int_type = .{881 .type_int_unsigned => .{ .int_type = .{
836 .signedness = .unsigned,882 .signedness = .unsigned,
837 .bits = @as(u16, @intCast(data)),883 .bits = @intCast(data),
838 } },884 } },
839 .type_float => .{ .float_type = .{885 .type_float => .{ .float_type = .{
840 .bits = @as(u16, @intCast(data)),886 .bits = @intCast(data),
841 } },887 } },
842 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },888 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },
843 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },889 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },
...@@ -846,40 +892,50 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -846,40 +892,50 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
846 return .{892 return .{
847 .function_type = .{893 .function_type = .{
848 .return_type = payload.data.return_type,894 .return_type = payload.data.return_type,
849 .parameters = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len])),895 .parameters = @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len]),
850 },896 },
851 };897 };
852 },898 },
853 .type_ptr_generic => .{899 // .type_ptr_generic => .{
854 .ptr_type = .{900 // .ptr_type = .{
855 .storage_class = .Generic,901 // .storage_class = .Generic,
856 .child_type = @as(Ref, @enumFromInt(data)),902 // .child_type = @enumFromInt(data),
857 },903 // },
858 },904 // },
859 .type_ptr_crosswgp => .{905 // .type_ptr_crosswgp => .{
860 .ptr_type = .{906 // .ptr_type = .{
861 .storage_class = .CrossWorkgroup,907 // .storage_class = .CrossWorkgroup,
862 .child_type = @as(Ref, @enumFromInt(data)),908 // .child_type = @enumFromInt(data),
863 },909 // },
864 },910 // },
865 .type_ptr_function => .{911 // .type_ptr_function => .{
866 .ptr_type = .{912 // .ptr_type = .{
867 .storage_class = .Function,913 // .storage_class = .Function,
868 .child_type = @as(Ref, @enumFromInt(data)),914 // .child_type = @enumFromInt(data),
869 },915 // },
870 },916 // },
871 .type_ptr_simple => {917 .type_ptr_simple => {
872 const payload = self.extraData(Tag.SimplePointerType, data);918 const payload = self.extraData(Tag.SimplePointerType, data);
873 return .{919 return .{
874 .ptr_type = .{920 .ptr_type = .{
875 .storage_class = payload.storage_class,921 .storage_class = payload.storage_class,
876 .child_type = payload.child_type,922 .child_type = payload.child_type,
923 .fwd = payload.fwd,
924 },
925 };
926 },
927 .type_fwd_ptr => {
928 const payload = self.extraData(Tag.ForwardPointerType, data);
929 return .{
930 .fwd_ptr_type = .{
931 .zig_child_type = payload.zig_child_type,
932 .storage_class = payload.storage_class,
877 },933 },
878 };934 };
879 },935 },
880 .type_struct_simple => {936 .type_struct_simple => {
881 const payload = self.extraDataTrail(Tag.SimpleStructType, data);937 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
882 const member_types = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]));938 const member_types: []const Ref = @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]);
883 return .{939 return .{
884 .struct_type = .{940 .struct_type = .{
885 .name = payload.data.name,941 .name = payload.data.name,
...@@ -891,8 +947,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -891,8 +947,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
891 .type_struct_simple_with_member_names => {947 .type_struct_simple_with_member_names => {
892 const payload = self.extraDataTrail(Tag.SimpleStructType, data);948 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
893 const trailing = self.extra.items[payload.trail..];949 const trailing = self.extra.items[payload.trail..];
894 const member_types = @as([]const Ref, @ptrCast(trailing[0..payload.data.members_len]));950 const member_types: []const Ref = @ptrCast(trailing[0..payload.data.members_len]);
895 const member_names = @as([]const String, @ptrCast(trailing[payload.data.members_len..][0..payload.data.members_len]));951 const member_names: []const String = @ptrCast(trailing[payload.data.members_len..][0..payload.data.members_len]);
896 return .{952 return .{
897 .struct_type = .{953 .struct_type = .{
898 .name = payload.data.name,954 .name = payload.data.name,
...@@ -903,16 +959,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -903,16 +959,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
903 },959 },
904 .type_opaque => .{960 .type_opaque => .{
905 .opaque_type = .{961 .opaque_type = .{
906 .name = @as(String, @enumFromInt(data)),962 .name = @enumFromInt(data),
907 },963 },
908 },964 },
909 .float16 => .{ .float = .{965 .float16 => .{ .float = .{
910 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),966 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),
911 .value = .{ .float16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },967 .value = .{ .float16 = @bitCast(@as(u16, @intCast(data))) },
912 } },968 } },
913 .float32 => .{ .float = .{969 .float32 => .{ .float = .{
914 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),970 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),
915 .value = .{ .float32 = @as(f32, @bitCast(data)) },971 .value = .{ .float32 = @bitCast(data) },
916 } },972 } },
917 .float64 => .{ .float = .{973 .float64 => .{ .float = .{
918 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),974 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),
...@@ -955,17 +1011,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -955,17 +1011,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
955 } };1011 } };
956 },1012 },
957 .undef => .{ .undef = .{1013 .undef => .{ .undef = .{
958 .ty = @as(Ref, @enumFromInt(data)),1014 .ty = @enumFromInt(data),
959 } },1015 } },
960 .null => .{ .null = .{1016 .null => .{ .null = .{
961 .ty = @as(Ref, @enumFromInt(data)),1017 .ty = @enumFromInt(data),
962 } },1018 } },
963 .bool_true => .{ .bool = .{1019 .bool_true => .{ .bool = .{
964 .ty = @as(Ref, @enumFromInt(data)),1020 .ty = @enumFromInt(data),
965 .value = true,1021 .value = true,
966 } },1022 } },
967 .bool_false => .{ .bool = .{1023 .bool_false => .{ .bool = .{
968 .ty = @as(Ref, @enumFromInt(data)),1024 .ty = @enumFromInt(data),
969 .value = false,1025 .value = false,
970 } },1026 } },
971 };1027 };
...@@ -981,7 +1037,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {...@@ -981,7 +1037,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {
981fn get(self: *const Self, key: Key) Ref {1037fn get(self: *const Self, key: Key) Ref {
982 const adapter: Key.Adapter = .{ .self = self };1038 const adapter: Key.Adapter = .{ .self = self };
983 const index = self.map.getIndexAdapted(key, adapter).?;1039 const index = self.map.getIndexAdapted(key, adapter).?;
984 return @as(Ref, @enumFromInt(index));1040 return @enumFromInt(index);
985}1041}
9861042
987fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {1043fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
...@@ -991,15 +1047,16 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {...@@ -991,15 +1047,16 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
991}1047}
9921048
993fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {1049fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {
994 const payload_offset = @as(u32, @intCast(self.extra.items.len));1050 const payload_offset: u32 = @intCast(self.extra.items.len);
995 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {1051 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
996 const field_val = @field(extra, field.name);1052 const field_val = @field(extra, field.name);
997 const word = switch (field.type) {1053 const word: u32 = switch (field.type) {
998 u32 => field_val,1054 u32 => field_val,
999 i32 => @as(u32, @bitCast(field_val)),1055 i32 => @bitCast(field_val),
1000 Ref => @intFromEnum(field_val),1056 Ref => @intFromEnum(field_val),
1001 StorageClass => @intFromEnum(field_val),1057 StorageClass => @intFromEnum(field_val),
1002 String => @intFromEnum(field_val),1058 String => @intFromEnum(field_val),
1059 InternPool.Index => @intFromEnum(field_val),
1003 else => @compileError("Invalid type: " ++ @typeName(field.type)),1060 else => @compileError("Invalid type: " ++ @typeName(field.type)),
1004 };1061 };
1005 self.extra.appendAssumeCapacity(word);1062 self.extra.appendAssumeCapacity(word);
...@@ -1018,10 +1075,11 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t...@@ -1018,10 +1075,11 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t
1018 const word = self.extra.items[offset + i];1075 const word = self.extra.items[offset + i];
1019 @field(result, field.name) = switch (field.type) {1076 @field(result, field.name) = switch (field.type) {
1020 u32 => word,1077 u32 => word,
1021 i32 => @as(i32, @bitCast(word)),1078 i32 => @bitCast(word),
1022 Ref => @as(Ref, @enumFromInt(word)),1079 Ref => @enumFromInt(word),
1023 StorageClass => @as(StorageClass, @enumFromInt(word)),1080 StorageClass => @enumFromInt(word),
1024 String => @as(String, @enumFromInt(word)),1081 String => @enumFromInt(word),
1082 InternPool.Index => @enumFromInt(word),
1025 else => @compileError("Invalid type: " ++ @typeName(field.type)),1083 else => @compileError("Invalid type: " ++ @typeName(field.type)),
1026 };1084 };
1027 }1085 }
...@@ -1049,7 +1107,7 @@ pub const String = enum(u32) {...@@ -1049,7 +1107,7 @@ pub const String = enum(u32) {
1049 _ = ctx;1107 _ = ctx;
1050 var hasher = std.hash.Wyhash.init(0);1108 var hasher = std.hash.Wyhash.init(0);
1051 hasher.update(a);1109 hasher.update(a);
1052 return @as(u32, @truncate(hasher.final()));1110 return @truncate(hasher.final());
1053 }1111 }
1054 };1112 };
1055};1113};
...@@ -1064,10 +1122,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {...@@ -1064,10 +1122,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {
1064 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);1122 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);
1065 self.string_bytes.appendSliceAssumeCapacity(str);1123 self.string_bytes.appendSliceAssumeCapacity(str);
1066 self.string_bytes.appendAssumeCapacity(0);1124 self.string_bytes.appendAssumeCapacity(0);
1067 entry.value_ptr.* = @as(u32, @intCast(offset));1125 entry.value_ptr.* = @intCast(offset);
1068 }1126 }
10691127
1070 return @as(String, @enumFromInt(entry.index));1128 return @enumFromInt(entry.index);
1071}1129}
10721130
1073pub fn getString(self: *const Self, ref: String) ?[]const u8 {1131pub fn getString(self: *const Self, ref: String) ?[]const u8 {
src/codegen/spirv/Module.zig-11
...@@ -507,17 +507,6 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {...@@ -507,17 +507,6 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {
507 } });507 } });
508}508}
509509
510pub fn ptrType(
511 self: *Module,
512 child: CacheRef,
513 storage_class: spec.StorageClass,
514) !CacheRef {
515 return try self.resolve(.{ .ptr_type = .{
516 .storage_class = storage_class,
517 .child_type = child,
518 } });
519}
520
521pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {510pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {
522 const ty = self.cache.lookup(ty_ref).int_type;511 const ty = self.cache.lookup(ty_ref).int_type;
523 const Value = Cache.Key.Int.Value;512 const Value = Cache.Key.Int.Value;
test/behavior/bugs/12000.zig-1
...@@ -9,7 +9,6 @@ test {...@@ -9,7 +9,6 @@ test {
9 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1312
14 var t: T = .{ .next = null };13 var t: T = .{ .next = null };
15 try std.testing.expect(t.next == null);14 try std.testing.expect(t.next == null);
test/behavior/bugs/1735.zig-1
...@@ -44,7 +44,6 @@ const a = struct {...@@ -44,7 +44,6 @@ const a = struct {
44test "initialization" {44test "initialization" {
45 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;45 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
46 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO46 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
4847
49 var t = a.init();48 var t = a.init();
50 try std.testing.expect(t.foo.len == 0);49 try std.testing.expect(t.foo.len == 0);
test/behavior/bugs/1914.zig-4
...@@ -12,8 +12,6 @@ const b_list: []B = &[_]B{};...@@ -12,8 +12,6 @@ const b_list: []B = &[_]B{};
12const a = A{ .b_list_pointer = &b_list };12const a = A{ .b_list_pointer = &b_list };
1313
14test "segfault bug" {14test "segfault bug" {
15 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16
17 const assert = std.debug.assert;15 const assert = std.debug.assert;
18 const obj = B{ .a_pointer = &a };16 const obj = B{ .a_pointer = &a };
19 assert(obj.a_pointer == &a); // this makes zig crash17 assert(obj.a_pointer == &a); // this makes zig crash
...@@ -30,7 +28,5 @@ pub const B2 = struct {...@@ -30,7 +28,5 @@ pub const B2 = struct {
30var b_value = B2{ .pointer_array = &[_]*A2{} };28var b_value = B2{ .pointer_array = &[_]*A2{} };
3129
32test "basic stuff" {30test "basic stuff" {
33 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34
35 std.debug.assert(&b_value == &b_value);31 std.debug.assert(&b_value == &b_value);
36}32}
test/behavior/bugs/2006.zig-1
...@@ -7,7 +7,6 @@ const S = struct {...@@ -7,7 +7,6 @@ const S = struct {
7};7};
8test "bug 2006" {8test "bug 2006" {
9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1110
12 var a: S = undefined;11 var a: S = undefined;
13 a = S{ .p = undefined };12 a = S{ .p = undefined };
test/behavior/bugs/3007.zig-1
...@@ -22,7 +22,6 @@ test "fixed" {...@@ -22,7 +22,6 @@ test "fixed" {
22 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;22 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO23 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO24 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2625
27 default_foo = get_foo() catch null; // This Line26 default_foo = get_foo() catch null; // This Line
28 try std.testing.expect(!default_foo.?.free);27 try std.testing.expect(!default_foo.?.free);
test/behavior/bugs/6947.zig-1
...@@ -8,7 +8,6 @@ test {...@@ -8,7 +8,6 @@ test {
8 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO8 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1211
13 var slice: []void = undefined;12 var slice: []void = undefined;
14 destroy(&slice[0]);13 destroy(&slice[0]);
test/behavior/bugs/7325.zig-1
...@@ -81,7 +81,6 @@ test {...@@ -81,7 +81,6 @@ test {
81 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO81 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
82 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO82 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
83 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO83 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8584
86 var param: ParamType = .{85 var param: ParamType = .{
87 .one_of = .{ .name = "name" },86 .one_of = .{ .name = "name" },
test/behavior/error.zig-1
...@@ -943,7 +943,6 @@ test "returning an error union containing a type with no runtime bits" {...@@ -943,7 +943,6 @@ test "returning an error union containing a type with no runtime bits" {
943test "try used in recursive function with inferred error set" {943test "try used in recursive function with inferred error set" {
944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
945 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO945 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
946 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
947946
948 const Value = union(enum) {947 const Value = union(enum) {
949 values: []const @This(),948 values: []const @This(),
test/behavior/eval.zig-4
...@@ -391,7 +391,6 @@ test "return 0 from function that has u0 return type" {...@@ -391,7 +391,6 @@ test "return 0 from function that has u0 return type" {
391test "statically initialized struct" {391test "statically initialized struct" {
392 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO392 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
394 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
395394
396 st_init_str_foo.x += 1;395 st_init_str_foo.x += 1;
397 try expect(st_init_str_foo.x == 14);396 try expect(st_init_str_foo.x == 14);
...@@ -498,7 +497,6 @@ test "comptime shlWithOverflow" {...@@ -498,7 +497,6 @@ test "comptime shlWithOverflow" {
498test "const ptr to variable data changes at runtime" {497test "const ptr to variable data changes at runtime" {
499 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO498 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO499 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
502500
503 try expect(foo_ref.name[0] == 'a');501 try expect(foo_ref.name[0] == 'a');
504 foo_ref.name = "b";502 foo_ref.name = "b";
...@@ -1551,8 +1549,6 @@ test "comptime function turns function value to function pointer" {...@@ -1551,8 +1549,6 @@ test "comptime function turns function value to function pointer" {
1551}1549}
15521550
1553test "container level const and var have unique addresses" {1551test "container level const and var have unique addresses" {
1554 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1555
1556 const S = struct {1552 const S = struct {
1557 x: i32,1553 x: i32,
1558 y: i32,1554 y: i32,
test/behavior/generics.zig-1
...@@ -205,7 +205,6 @@ fn foo2(arg: anytype) bool {...@@ -205,7 +205,6 @@ fn foo2(arg: anytype) bool {
205205
206test "generic struct" {206test "generic struct" {
207 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO207 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
208 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
209208
210 var a1 = GenNode(i32){209 var a1 = GenNode(i32){
211 .value = 13,210 .value = 13,
test/behavior/null.zig-1
...@@ -185,7 +185,6 @@ test "unwrap optional which is field of global var" {...@@ -185,7 +185,6 @@ test "unwrap optional which is field of global var" {
185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
189188
190 struct_with_optional.field = null;189 struct_with_optional.field = null;
191 if (struct_with_optional.field) |payload| {190 if (struct_with_optional.field) |payload| {
test/behavior/optional.zig-1
...@@ -193,7 +193,6 @@ test "nested orelse" {...@@ -193,7 +193,6 @@ test "nested orelse" {
193test "self-referential struct through a slice of optional" {193test "self-referential struct through a slice of optional" {
194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
197196
198 const S = struct {197 const S = struct {
199 const Node = struct {198 const Node = struct {
test/behavior/ptrcast.zig-2
...@@ -130,7 +130,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {...@@ -130,7 +130,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134133
135 // Test lowering a field ptr134 // Test lowering a field ptr
136 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };135 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
...@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr" {...@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr" {
153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO154 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157155
158 // Test lowering a field ptr156 // Test lowering a field ptr
159 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };157 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
test/behavior/struct.zig-6
...@@ -292,7 +292,6 @@ const Val = struct {...@@ -292,7 +292,6 @@ const Val = struct {
292test "struct point to self" {292test "struct point to self" {
293 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;293 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
294 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO294 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
296295
297 var root: Node = undefined;296 var root: Node = undefined;
298 root.val.x = 1;297 root.val.x = 1;
...@@ -347,7 +346,6 @@ test "self-referencing struct via array member" {...@@ -347,7 +346,6 @@ test "self-referencing struct via array member" {
347 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;346 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
348 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO347 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO348 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
351349
352 const T = struct {350 const T = struct {
353 children: [1]*@This(),351 children: [1]*@This(),
...@@ -370,7 +368,6 @@ const EmptyStruct = struct {...@@ -370,7 +368,6 @@ const EmptyStruct = struct {
370368
371test "align 1 field before self referential align 8 field as slice return type" {369test "align 1 field before self referential align 8 field as slice return type" {
372 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO370 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
374371
375 const result = alloc(Expr);372 const result = alloc(Expr);
376 try expect(result.len == 0);373 try expect(result.len == 0);
...@@ -736,7 +733,6 @@ test "packed struct with u0 field access" {...@@ -736,7 +733,6 @@ test "packed struct with u0 field access" {
736test "access to global struct fields" {733test "access to global struct fields" {
737 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO734 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
738 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO735 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
740736
741 g_foo.bar.value = 42;737 g_foo.bar.value = 42;
742 try expect(g_foo.bar.value == 42);738 try expect(g_foo.bar.value == 42);
...@@ -1423,7 +1419,6 @@ test "fieldParentPtr of a zero-bit field" {...@@ -1423,7 +1419,6 @@ test "fieldParentPtr of a zero-bit field" {
14231419
1424test "struct field has a pointer to an aligned version of itself" {1420test "struct field has a pointer to an aligned version of itself" {
1425 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1421 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1426 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14271422
1428 const E = struct {1423 const E = struct {
1429 next: *align(1) @This(),1424 next: *align(1) @This(),
...@@ -1519,7 +1514,6 @@ test "function pointer in struct returns the struct" {...@@ -1519,7 +1514,6 @@ test "function pointer in struct returns the struct" {
15191514
1520test "no dependency loop on optional field wrapped in generic function" {1515test "no dependency loop on optional field wrapped in generic function" {
1521 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1522 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15231517
1524 const S = struct {1518 const S = struct {
1525 fn Atomic(comptime T: type) type {1519 fn Atomic(comptime T: type) type {
test/behavior/struct_contains_null_ptr_itself.zig-1
...@@ -5,7 +5,6 @@ const builtin = @import("builtin");...@@ -5,7 +5,6 @@ const builtin = @import("builtin");
5test "struct contains null pointer which contains original struct" {5test "struct contains null pointer which contains original struct" {
6 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;6 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98
10 var x: ?*NodeLineComment = null;9 var x: ?*NodeLineComment = null;
11 try expect(x == null);10 try expect(x == null);
test/behavior/struct_contains_slice_of_itself.zig-2
...@@ -13,7 +13,6 @@ const NodeAligned = struct {...@@ -13,7 +13,6 @@ const NodeAligned = struct {
1313
14test "struct contains slice of itself" {14test "struct contains slice of itself" {
15 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO15 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1716
18 var other_nodes = [_]Node{17 var other_nodes = [_]Node{
19 Node{18 Node{
...@@ -54,7 +53,6 @@ test "struct contains slice of itself" {...@@ -54,7 +53,6 @@ test "struct contains slice of itself" {
54test "struct contains aligned slice of itself" {53test "struct contains aligned slice of itself" {
55 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO54 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO55 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5856
59 var other_nodes = [_]NodeAligned{57 var other_nodes = [_]NodeAligned{
60 NodeAligned{58 NodeAligned{
test/behavior/union.zig-10
...@@ -399,7 +399,6 @@ test "tagged union with no payloads" {...@@ -399,7 +399,6 @@ test "tagged union with no payloads" {
399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
403402
404 const a = UnionEnumNoPayloads{ .B = {} };403 const a = UnionEnumNoPayloads{ .B = {} };
405 switch (a) {404 switch (a) {
...@@ -474,7 +473,6 @@ test "update the tag value for zero-sized unions" {...@@ -474,7 +473,6 @@ test "update the tag value for zero-sized unions" {
474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;473 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
475 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;474 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO475 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
478476
479 const S = union(enum) {477 const S = union(enum) {
480 U0: void,478 U0: void,
...@@ -515,7 +513,6 @@ test "method call on an empty union" {...@@ -515,7 +513,6 @@ test "method call on an empty union" {
515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;513 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
517 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
519516
520 const S = struct {517 const S = struct {
521 const MyUnion = union(MyUnionTag) {518 const MyUnion = union(MyUnionTag) {
...@@ -593,7 +590,6 @@ test "tagged union with all void fields but a meaningful tag" {...@@ -593,7 +590,6 @@ test "tagged union with all void fields but a meaningful tag" {
593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;590 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;591 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO592 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
597593
598 const S = struct {594 const S = struct {
599 const B = union(enum) {595 const B = union(enum) {
...@@ -795,7 +791,6 @@ test "@unionInit stored to a const" {...@@ -795,7 +791,6 @@ test "@unionInit stored to a const" {
795 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO791 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
796 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO792 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
797 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO793 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
798 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
799794
800 const S = struct {795 const S = struct {
801 const U = union(enum) {796 const U = union(enum) {
...@@ -867,7 +862,6 @@ test "union no tag with struct member" {...@@ -867,7 +862,6 @@ test "union no tag with struct member" {
867 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO862 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
868 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
869 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
870 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
871865
872 const Struct = struct {};866 const Struct = struct {};
873 const Union = union {867 const Union = union {
...@@ -1079,7 +1073,6 @@ test "@unionInit on union with tag but no fields" {...@@ -1079,7 +1073,6 @@ test "@unionInit on union with tag but no fields" {
1079 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1073 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1080 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1074 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1081 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1075 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1082 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10831076
1084 const S = struct {1077 const S = struct {
1085 const Type = enum(u8) { no_op = 105 };1078 const Type = enum(u8) { no_op = 105 };
...@@ -1128,7 +1121,6 @@ test "global variable struct contains union initialized to non-most-aligned fiel...@@ -1128,7 +1121,6 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1128 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1129 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1130 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1123 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1131 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11321124
1133 const T = struct {1125 const T = struct {
1134 const U = union(enum) {1126 const U = union(enum) {
...@@ -1348,7 +1340,6 @@ test "union field ptr - zero sized payload" {...@@ -1348,7 +1340,6 @@ test "union field ptr - zero sized payload" {
1348 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1349 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1350 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1342 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1351 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13521343
1353 const U = union {1344 const U = union {
1354 foo: void,1345 foo: void,
...@@ -1363,7 +1354,6 @@ test "union field ptr - zero sized field" {...@@ -1363,7 +1354,6 @@ test "union field ptr - zero sized field" {
1363 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1354 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1364 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1365 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1356 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1366 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13671357
1368 const U = union {1358 const U = union {
1369 foo: void,1359 foo: void,