authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-10-22 12:15:31-07:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-10-22 12:15:31-07:00
log9f0359d78f9facc38418e32b0e8c1bf6f99f0d26
treec9427aa9886e8d7f84c50f2ef12407cc80fa61d1
parentfd2239bde9e2051a32fb25c50c732a40d4afccd0

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

This reverts commit b822e841cda0adabe3fec260ff51c18508f7ee32, reversing changes made to 0c99ba1eab63865592bb084feb271cd4e4b0357e. This caused a CI failure when it landed in master branch.

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

src/codegen/spirv.zig+309-292
......@@ -209,10 +209,6 @@ const DeclGen = struct {
209209 /// See Object.type_map
210210 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
216212 /// We need to keep track of result ids for block labels, as well as the 'incoming'
217213 /// blocks for a block.
218214 blocks: BlockMap = .{},
......@@ -299,7 +295,6 @@ const DeclGen = struct {
299295 pub fn deinit(self: *DeclGen) void {
300296 self.args.deinit(self.gpa);
301297 self.inst_results.deinit(self.gpa);
302 self.wip_pointers.deinit(self.gpa);
303298 self.blocks.deinit(self.gpa);
304299 self.func.deinit(self.gpa);
305300 self.base_line_stack.deinit(self.gpa);
......@@ -363,7 +358,8 @@ const DeclGen = struct {
363358
364359 const mod = self.module;
365360 const ty = mod.intern_pool.typeOf(val).toType();
366 const ptr_ty_ref = try self.ptrType(ty, storage_class);
361 const ty_ref = try self.resolveType(ty, .indirect);
362 const ptr_ty_ref = try self.spv.ptrType(ty_ref, storage_class);
367363
368364 const var_id = self.spv.declPtr(spv_decl_index).result_id;
369365
......@@ -586,41 +582,66 @@ const DeclGen = struct {
586582 }
587583
588584 /// Construct a struct at runtime.
589 /// ty must be a struct type.
585 /// result_ty_ref must be a struct type.
590586 /// Constituents should be in `indirect` representation (as the elements of a struct should be).
591587 /// Result is in `direct` representation.
592 fn constructStruct(self: *DeclGen, ty: Type, types: []const Type, constituents: []const IdRef) !IdRef {
593 assert(types.len == constituents.len);
588 fn constructStruct(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {
594589 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
595590 // operands are not constant.
596591 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
597592 // For now, just initialize the struct by setting the fields manually...
598593 // TODO: Make this OpCompositeConstruct when we can
599 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
600 for (constituents, types, 0..) |constitent_id, member_ty, index| {
601 const ptr_member_ty_ref = try self.ptrType(member_ty, .Function);
594 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);
595 const ptr_composite_id = self.spv.allocId();
596 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
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);
602607 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
603608 try self.func.body.emit(self.spv.gpa, .OpStore, .{
604609 .pointer = ptr_id,
605610 .object = constitent_id,
606611 });
607612 }
608 return try self.load(ty, ptr_composite_id, .{});
613 const result_id = self.spv.allocId();
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;
609620 }
610621
611622 /// Construct an array at runtime.
612 /// ty must be an array type.
623 /// result_ty_ref must be an array type.
613624 /// Constituents should be in `indirect` representation (as the elements of an array should be).
614625 /// Result is in `direct` representation.
615 fn constructArray(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef {
626 fn constructArray(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {
616627 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
617628 // operands are not constant.
618629 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
619630 // For now, just initialize the struct by setting the fields manually...
620631 // TODO: Make this OpCompositeConstruct when we can
621 const mod = self.module;
622 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
623 const ptr_elem_ty_ref = try self.ptrType(ty.elemType2(mod), .Function);
632 // TODO: Make this Function storage type
633 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);
634 const ptr_composite_id = self.spv.allocId();
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
624645 for (constituents, 0..) |constitent_id, index| {
625646 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
626647 try self.func.body.emit(self.spv.gpa, .OpStore, .{
......@@ -628,8 +649,13 @@ const DeclGen = struct {
628649 .object = constitent_id,
629650 });
630651 }
631
632 return try self.load(ty, ptr_composite_id, .{});
652 const result_id = self.spv.allocId();
653 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
654 .id_result_type = self.typeId(result_ty_ref),
655 .id_result = result_id,
656 .pointer = ptr_composite_id,
657 });
658 return result_id;
633659 }
634660
635661 /// This function generates a load for a constant in direct (ie, non-memory) representation.
......@@ -740,18 +766,15 @@ const DeclGen = struct {
740766 }.toValue();
741767
742768 var constituents: [2]IdRef = undefined;
743 var types: [2]Type = undefined;
744769 if (eu_layout.error_first) {
745770 constituents[0] = try self.constant(err_ty, err_val, .indirect);
746771 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);
747 types = .{ err_ty, payload_ty };
748772 } else {
749773 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);
750774 constituents[1] = try self.constant(err_ty, err_val, .indirect);
751 types = .{ payload_ty, err_ty };
752775 }
753776
754 return try self.constructStruct(ty, &types, &constituents);
777 return try self.constructStruct(result_ty_ref, &constituents);
755778 },
756779 .enum_tag => {
757780 const int_val = try val.intFromEnum(ty, mod);
......@@ -769,11 +792,7 @@ const DeclGen = struct {
769792 }
770793
771794 const len_id = try self.constant(Type.usize, ptr.len.toValue(), .indirect);
772 return try self.constructStruct(
773 ty,
774 &.{ ptr_ty, Type.usize },
775 &.{ ptr_id, len_id },
776 );
795 return try self.constructStruct(result_ty_ref, &.{ ptr_id, len_id });
777796 },
778797 .opt => {
779798 const payload_ty = ty.optionalChild(mod);
......@@ -800,11 +819,7 @@ const DeclGen = struct {
800819 else
801820 try self.spv.constUndef(try self.resolveType(payload_ty, .indirect));
802821
803 return try self.constructStruct(
804 ty,
805 &.{ payload_ty, Type.bool },
806 &.{ payload_id, has_pl_id },
807 );
822 return try self.constructStruct(result_ty_ref, &.{ payload_id, has_pl_id });
808823 },
809824 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {
810825 inline .array_type, .vector_type => |array_type, tag| {
......@@ -842,7 +857,7 @@ const DeclGen = struct {
842857 else => {},
843858 }
844859
845 return try self.constructArray(ty, constituents);
860 return try self.constructArray(result_ty_ref, constituents);
846861 },
847862 .struct_type => {
848863 const struct_type = mod.typeToStruct(ty).?;
......@@ -850,9 +865,6 @@ const DeclGen = struct {
850865 return self.todo("packed struct constants", .{});
851866 }
852867
853 var types = std.ArrayList(Type).init(self.gpa);
854 defer types.deinit();
855
856868 var constituents = std.ArrayList(IdRef).init(self.gpa);
857869 defer constituents.deinit();
858870
......@@ -868,23 +880,22 @@ const DeclGen = struct {
868880 const field_val = try val.fieldValue(mod, field_index);
869881 const field_id = try self.constant(field_ty, field_val, .indirect);
870882
871 try types.append(field_ty);
872883 try constituents.append(field_id);
873884 }
874885
875 return try self.constructStruct(ty, types.items, constituents.items);
886 return try self.constructStruct(result_ty_ref, constituents.items);
876887 },
877888 .anon_struct_type => unreachable, // TODO
878889 else => unreachable,
879890 },
880891 .un => |un| {
881892 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;
882 const union_obj = mod.typeToUnion(ty).?;
883 const field_ty = union_obj.field_types.get(ip)[active_field].toType();
884 const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(mod))
885 try self.constant(field_ty, un.val.toValue(), .direct)
893 const layout = self.unionLayout(ty, active_field);
894 const payload = if (layout.active_field_size != 0)
895 try self.constant(layout.active_field_ty, un.val.toValue(), .indirect)
886896 else
887897 null;
898
888899 return try self.unionInit(ty, active_field, payload);
889900 },
890901 .memoized_call => unreachable,
......@@ -923,7 +934,8 @@ const DeclGen = struct {
923934
924935 // TODO: Can we consolidate this in ptrElemPtr?
925936 const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
926 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
937 const elem_ty_ref = try self.resolveType(elem_ty, .direct);
938 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
927939
928940 if (elem_ptr_ty_ref == result_ty_ref) {
929941 return elem_ptr_id;
......@@ -985,7 +997,8 @@ const DeclGen = struct {
985997 };
986998
987999 const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);
988 const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class);
1000 const decl_ty_ref = try self.resolveType(decl_ty, .indirect);
1001 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
9891002
9901003 const ptr_id = switch (final_storage_class) {
9911004 .Generic => blk: {
......@@ -1041,7 +1054,8 @@ const DeclGen = struct {
10411054
10421055 const final_storage_class = spvStorageClass(decl.@"addrspace");
10431056
1044 const decl_ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);
1057 const decl_ty_ref = try self.resolveType(decl.ty, .indirect);
1058 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
10451059
10461060 const ptr_id = switch (final_storage_class) {
10471061 .Generic => blk: {
......@@ -1109,52 +1123,29 @@ const DeclGen = struct {
11091123 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());
11101124 }
11111125
1112 fn ptrType(self: *DeclGen, child_ty: Type, storage_class: StorageClass) !CacheRef {
1113 const key = .{ child_ty.toIntern(), storage_class };
1114 const entry = try self.wip_pointers.getOrPut(self.gpa, key);
1115 if (entry.found_existing) {
1116 const fwd_ref = entry.value_ptr.*;
1117 try self.spv.cache.recursive_ptrs.put(self.spv.gpa, fwd_ref, {});
1118 return fwd_ref;
1119 }
1120
1121 const fwd_ref = try self.spv.resolve(.{ .fwd_ptr_type = .{
1122 .zig_child_type = child_ty.toIntern(),
1123 .storage_class = storage_class,
1124 } });
1125 entry.value_ptr.* = fwd_ref;
1126
1127 const child_ty_ref = try self.resolveType(child_ty, .indirect);
1128 _ = try self.spv.resolve(.{ .ptr_type = .{
1129 .storage_class = storage_class,
1130 .child_type = child_ty_ref,
1131 .fwd = fwd_ref,
1132 } });
1133
1134 assert(self.wip_pointers.remove(key));
1135
1136 return fwd_ref;
1137 }
1138
1139 /// Generate a union type. Union types are always generated with the
1140 /// most aligned field active. If the tag alignment is greater
1141 /// than that of the payload, a regular union (non-packed, with both tag and
1142 /// payload), will be generated as follows:
1126 /// Generate a union type, optionally with a known field. If the tag alignment is greater
1127 /// than that of the payload, a regular union (non-packed, with both tag and payload), will
1128 /// be generated as follows:
1129 /// If the active field is known:
11431130 /// struct {
11441131 /// tag: TagType,
1145 /// payload: MostAlignedFieldType,
1146 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1132 /// payload: ActivePayloadType,
1133 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
11471134 /// padding: [padding_size]u8,
11481135 /// }
11491136 /// If the payload alignment is greater than that of the tag:
11501137 /// struct {
1151 /// payload: MostAlignedFieldType,
1152 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1138 /// payload: ActivePayloadType,
1139 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
11531140 /// tag: TagType,
11541141 /// padding: [padding_size]u8,
11551142 /// }
1143 /// If the active payload is unknown, it will default back to the most aligned field. This is
1144 /// to make sure that the overal struct has the correct alignment in spir-v.
11561145 /// If any of the fields' size is 0, it will be omitted.
1157 fn resolveUnionType(self: *DeclGen, ty: Type) !CacheRef {
1146 /// NOTE: When the active field is set to something other than the most aligned field, the
1147 /// resulting struct will be *underaligned*.
1148 fn resolveUnionType(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !CacheRef {
11581149 const mod = self.module;
11591150 const ip = &mod.intern_pool;
11601151 const union_obj = mod.typeToUnion(ty).?;
......@@ -1163,13 +1154,17 @@ const DeclGen = struct {
11631154 return self.todo("packed union types", .{});
11641155 }
11651156
1166 const layout = self.unionLayout(ty);
1167 if (!layout.has_payload) {
1157 const layout = self.unionLayout(ty, maybe_active_field);
1158
1159 if (layout.payload_size == 0) {
11681160 // No payload, so represent this as just the tag type.
11691161 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);
11701162 }
11711163
1172 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1164 // TODO: We need to add the active field to the key, somehow.
1165 if (maybe_active_field == null) {
1166 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1167 }
11731168
11741169 var member_types: [4]CacheRef = undefined;
11751170 var member_names: [4]CacheString = undefined;
......@@ -1182,10 +1177,10 @@ const DeclGen = struct {
11821177 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");
11831178 }
11841179
1185 if (layout.payload_size != 0) {
1186 const payload_ty_ref = try self.resolveType(layout.payload_ty, .indirect);
1187 member_types[layout.payload_index] = payload_ty_ref;
1188 member_names[layout.payload_index] = try self.spv.resolveString("(payload)");
1180 if (layout.active_field_size != 0) {
1181 const active_payload_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);
1182 member_types[layout.active_field_index] = active_payload_ty_ref;
1183 member_names[layout.active_field_index] = try self.spv.resolveString("(payload)");
11891184 }
11901185
11911186 if (layout.payload_padding_size != 0) {
......@@ -1206,7 +1201,9 @@ const DeclGen = struct {
12061201 .member_names = member_names[0..layout.total_fields],
12071202 } });
12081203
1209 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1204 if (maybe_active_field == null) {
1205 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1206 }
12101207 return ty_ref;
12111208 }
12121209
......@@ -1354,12 +1351,12 @@ const DeclGen = struct {
13541351 .Pointer => {
13551352 const ptr_info = ty.ptrInfo(mod);
13561353
1357 // Note: Don't cache this pointer type, it would mess up the recursive pointer functionality
1358 // in ptrType()!
1359
13601354 const storage_class = spvStorageClass(ptr_info.flags.address_space);
1361 const ptr_ty_ref = try self.ptrType(ptr_info.child.toType(), storage_class);
1362
1355 const child_ty_ref = try self.resolveType(ptr_info.child.toType(), .indirect);
1356 const ptr_ty_ref = try self.spv.resolve(.{ .ptr_type = .{
1357 .storage_class = storage_class,
1358 .child_type = child_ty_ref,
1359 } });
13631360 if (ptr_info.flags.size != .Slice) {
13641361 return ptr_ty_ref;
13651362 }
......@@ -1474,7 +1471,7 @@ const DeclGen = struct {
14741471 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
14751472 return ty_ref;
14761473 },
1477 .Union => return try self.resolveUnionType(ty),
1474 .Union => return try self.resolveUnionType(ty, null),
14781475 .ErrorSet => return try self.intType(.unsigned, 16),
14791476 .ErrorUnion => {
14801477 const payload_ty = ty.errorUnionPayload(mod);
......@@ -1588,16 +1585,14 @@ const DeclGen = struct {
15881585 }
15891586
15901587 const UnionLayout = struct {
1591 /// If false, this union is represented
1592 /// by only an integer of the tag type.
1593 has_payload: bool,
1588 active_field: u32,
1589 active_field_ty: Type,
1590 payload_size: u32,
1591
15941592 tag_size: u32,
15951593 tag_index: u32,
1596 /// Note: This is the size of the payload type itself, NOT the size of the ENTIRE payload.
1597 /// Use `has_payload` instead!!
1598 payload_ty: Type,
1599 payload_size: u32,
1600 payload_index: u32,
1594 active_field_size: u32,
1595 active_field_index: u32,
16011596 payload_padding_size: u32,
16021597 payload_padding_index: u32,
16031598 padding_size: u32,
......@@ -1605,19 +1600,23 @@ const DeclGen = struct {
16051600 total_fields: u32,
16061601 };
16071602
1608 fn unionLayout(self: *DeclGen, ty: Type) UnionLayout {
1603 fn unionLayout(self: *DeclGen, ty: Type, maybe_active_field: ?usize) UnionLayout {
16091604 const mod = self.module;
16101605 const ip = &mod.intern_pool;
16111606 const layout = ty.unionGetLayout(self.module);
16121607 const union_obj = mod.typeToUnion(ty).?;
16131608
1609 const active_field = maybe_active_field orelse layout.most_aligned_field;
1610 const active_field_ty = union_obj.field_types.get(ip)[active_field].toType();
1611
16141612 var union_layout = UnionLayout{
1615 .has_payload = layout.payload_size != 0,
1613 .active_field = @intCast(active_field),
1614 .active_field_ty = active_field_ty,
1615 .payload_size = @intCast(layout.payload_size),
16161616 .tag_size = @intCast(layout.tag_size),
16171617 .tag_index = undefined,
1618 .payload_ty = undefined,
1619 .payload_size = undefined,
1620 .payload_index = undefined,
1618 .active_field_size = undefined,
1619 .active_field_index = undefined,
16211620 .payload_padding_size = undefined,
16221621 .payload_padding_index = undefined,
16231622 .padding_size = @intCast(layout.padding),
......@@ -1625,16 +1624,11 @@ const DeclGen = struct {
16251624 .total_fields = undefined,
16261625 };
16271626
1628 if (union_layout.has_payload) {
1629 const most_aligned_field = layout.most_aligned_field;
1630 const most_aligned_field_ty = union_obj.field_types.get(ip)[most_aligned_field].toType();
1631 union_layout.payload_ty = most_aligned_field_ty;
1632 union_layout.payload_size = @intCast(most_aligned_field_ty.abiSize(mod));
1633 } else {
1634 union_layout.payload_size = 0;
1635 }
1636
1637 union_layout.payload_padding_size = @intCast(layout.payload_size - union_layout.payload_size);
1627 union_layout.active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime(mod))
1628 @intCast(active_field_ty.abiSize(mod))
1629 else
1630 0;
1631 union_layout.payload_padding_size = @intCast(layout.payload_size - union_layout.active_field_size);
16381632
16391633 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);
16401634 var field_index: u32 = 0;
......@@ -1644,8 +1638,8 @@ const DeclGen = struct {
16441638 field_index += 1;
16451639 }
16461640
1647 if (union_layout.payload_size != 0) {
1648 union_layout.payload_index = field_index;
1641 if (union_layout.active_field_size != 0) {
1642 union_layout.active_field_index = field_index;
16491643 field_index += 1;
16501644 }
16511645
......@@ -1689,7 +1683,7 @@ const DeclGen = struct {
16891683 /// the name of an error in the text executor.
16901684 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {
16911685 const anyerror_ty_ref = try self.resolveType(Type.anyerror, .direct);
1692 const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup);
1686 const ptr_anyerror_ty_ref = try self.spv.ptrType(anyerror_ty_ref, .CrossWorkgroup);
16931687 const void_ty_ref = try self.resolveType(Type.void, .direct);
16941688
16951689 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
......@@ -1724,7 +1718,6 @@ const DeclGen = struct {
17241718 .id_result = error_id,
17251719 .function = test_id,
17261720 });
1727 // Note: Convert to direct not required.
17281721 try section.emit(self.spv.gpa, .OpStore, .{
17291722 .pointer = p_error_id,
17301723 .object = error_id,
......@@ -1829,7 +1822,8 @@ const DeclGen = struct {
18291822 else => final_storage_class,
18301823 };
18311824
1832 const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class);
1825 const ty_ref = try self.resolveType(decl.ty, .indirect);
1826 const ptr_ty_ref = try self.spv.ptrType(ty_ref, actual_storage_class);
18331827
18341828 const begin = self.spv.beginGlobal();
18351829 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{
......@@ -1934,15 +1928,11 @@ const DeclGen = struct {
19341928 return try self.convertToDirect(result_ty, result_id);
19351929 }
19361930
1937 const MemoryOptions = struct {
1938 is_volatile: bool = false,
1939 };
1940
1941 fn load(self: *DeclGen, value_ty: Type, ptr_id: IdRef, options: MemoryOptions) !IdRef {
1931 fn load(self: *DeclGen, value_ty: Type, ptr_id: IdRef, is_volatile: bool) !IdRef {
19421932 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
19431933 const result_id = self.spv.allocId();
19441934 const access = spec.MemoryAccess.Extended{
1945 .Volatile = options.is_volatile,
1935 .Volatile = is_volatile,
19461936 };
19471937 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
19481938 .id_result_type = self.typeId(indirect_value_ty_ref),
......@@ -1953,10 +1943,10 @@ const DeclGen = struct {
19531943 return try self.convertToDirect(value_ty, result_id);
19541944 }
19551945
1956 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, options: MemoryOptions) !void {
1946 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, is_volatile: bool) !void {
19571947 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
19581948 const access = spec.MemoryAccess.Extended{
1959 .Volatile = options.is_volatile,
1949 .Volatile = is_volatile,
19601950 };
19611951 try self.func.body.emit(self.spv.gpa, .OpStore, .{
19621952 .pointer = ptr_id,
......@@ -2128,7 +2118,9 @@ const DeclGen = struct {
21282118 constituent.* = try self.convertToIndirect(child_ty, result_id);
21292119 }
21302120
2131 return try self.constructArray(ty, constituents);
2121 const result_ty = try self.resolveType(child_ty, .indirect);
2122 const result_ty_ref = try self.spv.arrayType(vector_len, result_ty);
2123 return try self.constructArray(result_ty_ref, constituents);
21322124 }
21332125
21342126 const result_id = self.spv.allocId();
......@@ -2189,7 +2181,7 @@ const DeclGen = struct {
21892181
21902182 const info = try self.arithmeticTypeInfo(result_ty);
21912183 // TODO: Use fmin for OpenCL
2192 const cmp_id = try self.cmp(op, Type.bool, result_ty, lhs_id, rhs_id);
2184 const cmp_id = try self.cmp(op, result_ty, lhs_id, rhs_id);
21932185 const selection_id = switch (info.class) {
21942186 .float => blk: {
21952187 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,
......@@ -2324,7 +2316,7 @@ const DeclGen = struct {
23242316 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);
23252317 }
23262318
2327 return self.constructArray(ty, constituents);
2319 return self.constructArray(result_ty_ref, constituents);
23282320 }
23292321
23302322 // Binary operations are generally applicable to both scalar and vector operations
......@@ -2480,11 +2472,11 @@ const DeclGen = struct {
24802472 // Construct the struct that Zig wants as result.
24812473 // The value should already be the correct type.
24822474 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);
2483 return try self.constructStruct(
2484 result_ty,
2485 &.{ operand_ty, ov_ty },
2486 &.{ value_id, ov_id },
2487 );
2475 const result_ty_ref = try self.resolveType(result_ty, .direct);
2476 return try self.constructStruct(result_ty_ref, &.{
2477 value_id,
2478 ov_id,
2479 });
24882480 }
24892481
24902482 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2642,7 +2634,6 @@ const DeclGen = struct {
26422634 fn cmp(
26432635 self: *DeclGen,
26442636 op: std.math.CompareOperator,
2645 result_ty: Type,
26462637 ty: Type,
26472638 lhs_id: IdRef,
26482639 rhs_id: IdRef,
......@@ -2683,7 +2674,7 @@ const DeclGen = struct {
26832674 if (ty.optionalReprIsPayload(mod)) {
26842675 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));
26852676 assert(!payload_ty.isSlice(mod));
2686 return self.cmp(op, Type.bool, payload_ty, lhs_id, rhs_id);
2677 return self.cmp(op, payload_ty, lhs_id, rhs_id);
26872678 }
26882679
26892680 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
......@@ -2696,7 +2687,7 @@ const DeclGen = struct {
26962687 else
26972688 try self.convertToDirect(Type.bool, rhs_id);
26982689
2699 const valid_cmp_id = try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id);
2690 const valid_cmp_id = try self.cmp(op, Type.bool, lhs_valid_id, rhs_valid_id);
27002691 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
27012692 return valid_cmp_id;
27022693 }
......@@ -2707,7 +2698,7 @@ const DeclGen = struct {
27072698 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);
27082699 const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);
27092700
2710 const pl_cmp_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id);
2701 const pl_cmp_id = try self.cmp(op, payload_ty, lhs_pl_id, rhs_pl_id);
27112702
27122703 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl
27132704 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl
......@@ -2729,6 +2720,7 @@ const DeclGen = struct {
27292720 .Vector => {
27302721 const child_ty = ty.childType(mod);
27312722 const vector_len = ty.vectorLen(mod);
2723 const bool_ty_ref_indirect = try self.resolveType(Type.bool, .indirect);
27322724
27332725 var constituents = try self.gpa.alloc(IdRef, vector_len);
27342726 defer self.gpa.free(constituents);
......@@ -2736,11 +2728,12 @@ const DeclGen = struct {
27362728 for (constituents, 0..) |*constituent, i| {
27372729 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));
27382730 const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));
2739 const result_id = try self.cmp(op, Type.bool, child_ty, lhs_index_id, rhs_index_id);
2731 const result_id = try self.cmp(op, child_ty, lhs_index_id, rhs_index_id);
27402732 constituent.* = try self.convertToIndirect(Type.bool, result_id);
27412733 }
27422734
2743 return try self.constructArray(result_ty, constituents);
2735 const result_ty_ref = try self.spv.arrayType(vector_len, bool_ty_ref_indirect);
2736 return try self.constructArray(result_ty_ref, constituents);
27442737 },
27452738 else => unreachable,
27462739 };
......@@ -2813,9 +2806,8 @@ const DeclGen = struct {
28132806 const lhs_id = try self.resolve(bin_op.lhs);
28142807 const rhs_id = try self.resolve(bin_op.rhs);
28152808 const ty = self.typeOf(bin_op.lhs);
2816 const result_ty = self.typeOfIndex(inst);
28172809
2818 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
2810 return try self.cmp(op, ty, lhs_id, rhs_id);
28192811 }
28202812
28212813 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2827,9 +2819,8 @@ const DeclGen = struct {
28272819 const rhs_id = try self.resolve(vec_cmp.rhs);
28282820 const op = vec_cmp.compareOperator();
28292821 const ty = self.typeOf(vec_cmp.lhs);
2830 const result_ty = self.typeOfIndex(inst);
28312822
2832 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
2823 return try self.cmp(op, ty, lhs_id, rhs_id);
28332824 }
28342825
28352826 fn bitCast(
......@@ -2874,17 +2865,23 @@ const DeclGen = struct {
28742865 return result_id;
28752866 }
28762867
2877 const dst_ptr_ty_ref = try self.ptrType(dst_ty, .Function);
2868 const src_ptr_ty_ref = try self.spv.ptrType(src_ty_ref, .Function);
2869 const dst_ptr_ty_ref = try self.spv.ptrType(dst_ty_ref, .Function);
28782870
2879 const tmp_id = try self.alloc(src_ty, .{ .storage_class = .Function });
2880 try self.store(src_ty, tmp_id, src_id, .{});
2871 const tmp_id = self.spv.allocId();
2872 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
2873 .id_result_type = self.typeId(src_ptr_ty_ref),
2874 .id_result = tmp_id,
2875 .storage_class = .Function,
2876 });
2877 try self.store(src_ty, tmp_id, src_id, false);
28812878 const casted_ptr_id = self.spv.allocId();
28822879 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
28832880 .id_result_type = self.typeId(dst_ptr_ty_ref),
28842881 .id_result = casted_ptr_id,
28852882 .operand = tmp_id,
28862883 });
2887 return try self.load(dst_ty, casted_ptr_id, .{});
2884 return try self.load(dst_ty, casted_ptr_id, false);
28882885 }
28892886
28902887 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3063,6 +3060,7 @@ const DeclGen = struct {
30633060 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
30643061
30653062 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);
3063 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
30663064 const size_ty_ref = try self.sizeType();
30673065
30683066 const array_ptr_id = try self.resolve(ty_op.operand);
......@@ -3075,11 +3073,7 @@ const DeclGen = struct {
30753073 // Convert the pointer-to-array to a pointer to the first element.
30763074 try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});
30773075
3078 return try self.constructStruct(
3079 slice_ty,
3080 &.{ elem_ptr_ty, Type.usize },
3081 &.{ elem_ptr_id, len_id },
3082 );
3076 return try self.constructStruct(slice_ty_ref, &.{ elem_ptr_id, len_id });
30833077 }
30843078
30853079 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3089,16 +3083,13 @@ const DeclGen = struct {
30893083 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
30903084 const ptr_id = try self.resolve(bin_op.lhs);
30913085 const len_id = try self.resolve(bin_op.rhs);
3092 const ptr_ty = self.typeOf(bin_op.lhs);
30933086 const slice_ty = self.typeOfIndex(inst);
3087 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
30943088
3095 // Note: Types should not need to be converted to direct, these types
3096 // dont need to be converted.
3097 return try self.constructStruct(
3098 slice_ty,
3099 &.{ ptr_ty, Type.usize },
3100 &.{ ptr_id, len_id },
3101 );
3089 return try self.constructStruct(slice_ty_ref, &.{
3090 ptr_id, // Note: Type should not need to be converted to direct.
3091 len_id, // Note: Type should not need to be converted to direct.
3092 });
31023093 }
31033094
31043095 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3108,6 +3099,7 @@ const DeclGen = struct {
31083099 const ip = &mod.intern_pool;
31093100 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
31103101 const result_ty = self.typeOfIndex(inst);
3102 const result_ty_ref = try self.resolveType(result_ty, .direct);
31113103 const len: usize = @intCast(result_ty.arrayLen(mod));
31123104 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
31133105
......@@ -3119,8 +3111,6 @@ const DeclGen = struct {
31193111 unreachable; // TODO
31203112 }
31213113
3122 const types = try self.gpa.alloc(Type, elements.len);
3123 defer self.gpa.free(types);
31243114 const constituents = try self.gpa.alloc(IdRef, elements.len);
31253115 defer self.gpa.free(constituents);
31263116 var index: usize = 0;
......@@ -3132,7 +3122,6 @@ const DeclGen = struct {
31323122 assert(field_ty.toType().hasRuntimeBits(mod));
31333123
31343124 const id = try self.resolve(element);
3135 types[index] = field_ty.toType();
31363125 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);
31373126 index += 1;
31383127 }
......@@ -3146,7 +3135,6 @@ const DeclGen = struct {
31463135 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));
31473136
31483137 const id = try self.resolve(element);
3149 types[index] = field_ty;
31503138 constituents[index] = try self.convertToIndirect(field_ty, id);
31513139 index += 1;
31523140 }
......@@ -3154,11 +3142,7 @@ const DeclGen = struct {
31543142 else => unreachable,
31553143 }
31563144
3157 return try self.constructStruct(
3158 result_ty,
3159 types[0..index],
3160 constituents[0..index],
3161 );
3145 return try self.constructStruct(result_ty_ref, constituents[0..index]);
31623146 },
31633147 .Array => {
31643148 const array_info = result_ty.arrayInfo(mod);
......@@ -3175,7 +3159,7 @@ const DeclGen = struct {
31753159 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);
31763160 }
31773161
3178 return try self.constructArray(result_ty, elem_ids);
3162 return try self.constructArray(result_ty_ref, elem_ids);
31793163 },
31803164 else => unreachable,
31813165 }
......@@ -3260,14 +3244,15 @@ const DeclGen = struct {
32603244
32613245 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
32623246 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});
3263 return try self.load(slice_ty.childType(mod), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(mod) });
3247 return try self.load(slice_ty.childType(mod), elem_ptr, slice_ty.isVolatilePtr(mod));
32643248 }
32653249
32663250 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
32673251 const mod = self.module;
32683252 // Construct new pointer type for the resulting pointer
32693253 const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
3270 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
3254 const elem_ty_ref = try self.resolveType(elem_ty, .direct);
3255 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
32713256 if (ptr_ty.isSinglePointer(mod)) {
32723257 // Pointer-to-array. In this case, the resulting pointer is not of the same type
32733258 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.
......@@ -3303,7 +3288,9 @@ const DeclGen = struct {
33033288 const mod = self.module;
33043289 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
33053290 const array_ty = self.typeOf(bin_op.lhs);
3291 const array_ty_ref = try self.resolveType(array_ty, .direct);
33063292 const elem_ty = array_ty.childType(mod);
3293 const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
33073294 const array_id = try self.resolve(bin_op.lhs);
33083295 const index_id = try self.resolve(bin_op.rhs);
33093296
......@@ -3311,12 +3298,22 @@ const DeclGen = struct {
33113298 // For now, just generate a temporary and use that.
33123299 // TODO: This backend probably also should use isByRef from llvm...
33133300
3314 const elem_ptr_ty_ref = try self.ptrType(elem_ty, .Function);
3301 const array_ptr_ty_ref = try self.spv.ptrType(array_ty_ref, .Function);
3302 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, .Function);
3303
3304 const tmp_id = self.spv.allocId();
3305 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3306 .id_result_type = self.typeId(array_ptr_ty_ref),
3307 .id_result = tmp_id,
3308 .storage_class = .Function,
3309 });
3310 try self.func.body.emit(self.spv.gpa, .OpStore, .{
3311 .pointer = tmp_id,
3312 .object = array_id,
3313 });
33153314
3316 const tmp_id = try self.alloc(array_ty, .{ .storage_class = .Function });
3317 try self.store(array_ty, tmp_id, array_id, .{});
33183315 const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id});
3319 return try self.load(elem_ty, elem_ptr_id, .{});
3316 return try self.load(elem_ty, elem_ptr_id, false);
33203317 }
33213318
33223319 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3329,7 +3326,7 @@ const DeclGen = struct {
33293326 const ptr_id = try self.resolve(bin_op.lhs);
33303327 const index_id = try self.resolve(bin_op.rhs);
33313328 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
3332 return try self.load(elem_ty, elem_ptr_id, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3329 return try self.load(elem_ty, elem_ptr_id, ptr_ty.isVolatilePtr(mod));
33333330 }
33343331
33353332 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3337,21 +3334,22 @@ const DeclGen = struct {
33373334 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
33383335 const un_ptr_ty = self.typeOf(bin_op.lhs);
33393336 const un_ty = un_ptr_ty.childType(mod);
3340 const layout = self.unionLayout(un_ty);
3337 const layout = self.unionLayout(un_ty, null);
33413338
33423339 if (layout.tag_size == 0) return;
33433340
33443341 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
3345 const tag_ptr_ty_ref = try self.ptrType(tag_ty, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
3342 const tag_ty_ref = try self.resolveType(tag_ty, .indirect);
3343 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
33463344
33473345 const union_ptr_id = try self.resolve(bin_op.lhs);
33483346 const new_tag_id = try self.resolve(bin_op.rhs);
33493347
3350 if (!layout.has_payload) {
3351 try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
3348 if (layout.payload_size == 0) {
3349 try self.store(tag_ty, union_ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));
33523350 } else {
33533351 const ptr_id = try self.accessChain(tag_ptr_ty_ref, union_ptr_id, &.{layout.tag_index});
3354 try self.store(tag_ty, ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
3352 try self.store(tag_ty, ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));
33553353 }
33563354 }
33573355
......@@ -3362,11 +3360,11 @@ const DeclGen = struct {
33623360 const un_ty = self.typeOf(ty_op.operand);
33633361
33643362 const mod = self.module;
3365 const layout = self.unionLayout(un_ty);
3363 const layout = self.unionLayout(un_ty, null);
33663364 if (layout.tag_size == 0) return null;
33673365
33683366 const union_handle = try self.resolve(ty_op.operand);
3369 if (!layout.has_payload) return union_handle;
3367 if (layout.payload_size == 0) return union_handle;
33703368
33713369 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
33723370 return try self.extractField(tag_ty, union_handle, layout.tag_index);
......@@ -3379,8 +3377,8 @@ const DeclGen = struct {
33793377 payload: ?IdRef,
33803378 ) !IdRef {
33813379 // To initialize a union, generate a temporary variable with the
3382 // union type, then get the field pointer and pointer-cast it to the
3383 // right type to store it. Finally load the entire union.
3380 // type that has the right field active, then pointer-cast and store
3381 // the active field, and finally load and return the entire union.
33843382
33853383 const mod = self.module;
33863384 const ip = &mod.intern_pool;
......@@ -3391,7 +3389,7 @@ const DeclGen = struct {
33913389 }
33923390
33933391 const maybe_tag_ty = ty.unionTagTypeSafety(mod);
3394 const layout = self.unionLayout(ty);
3392 const layout = self.unionLayout(ty, active_field);
33953393
33963394 const tag_int = if (layout.tag_size != 0) blk: {
33973395 const tag_ty = maybe_tag_ty.?;
......@@ -3402,34 +3400,42 @@ const DeclGen = struct {
34023400 break :blk tag_int_val.toUnsignedInt(mod);
34033401 } else 0;
34043402
3405 if (!layout.has_payload) {
3403 if (layout.payload_size == 0) {
34063404 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
34073405 return try self.constInt(tag_ty_ref, tag_int);
34083406 }
34093407
3410 const tmp_id = try self.alloc(ty, .{ .storage_class = .Function });
3408 const un_active_ty_ref = try self.resolveUnionType(ty, active_field);
3409 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, .Function);
3410 const un_general_ty_ref = try self.resolveType(ty, .direct);
3411 const un_general_ptr_ty_ref = try self.spv.ptrType(un_general_ty_ref, .Function);
3412
3413 const tmp_id = self.spv.allocId();
3414 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3415 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3416 .id_result = tmp_id,
3417 .storage_class = .Function,
3418 });
34113419
34123420 if (layout.tag_size != 0) {
34133421 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
3414 const tag_ptr_ty_ref = try self.ptrType(maybe_tag_ty.?, .Function);
3422 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, .Function);
34153423 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});
34163424 const tag_id = try self.constInt(tag_ty_ref, tag_int);
3417 try self.store(maybe_tag_ty.?, ptr_id, tag_id, .{});
3425 try self.func.body.emit(self.spv.gpa, .OpStore, .{
3426 .pointer = ptr_id,
3427 .object = tag_id,
3428 });
34183429 }
34193430
3420 const payload_ty = union_ty.field_types.get(ip)[active_field].toType();
3421 if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3422 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3423 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3424 const active_pl_ptr_ty_ref = try self.ptrType(payload_ty, .Function);
3425 const active_pl_ptr_id = self.spv.allocId();
3426 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3427 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3428 .id_result = active_pl_ptr_id,
3429 .operand = pl_ptr_id,
3431 if (layout.active_field_size != 0) {
3432 const active_field_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);
3433 const active_field_ptr_ty_ref = try self.spv.ptrType(active_field_ty_ref, .Function);
3434 const ptr_id = try self.accessChain(active_field_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.active_field_index))});
3435 try self.func.body.emit(self.spv.gpa, .OpStore, .{
3436 .pointer = ptr_id,
3437 .object = payload.?,
34303438 });
3431
3432 try self.store(payload_ty, active_pl_ptr_id, payload.?, .{});
34333439 } else {
34343440 assert(payload == null);
34353441 }
......@@ -3437,21 +3443,34 @@ const DeclGen = struct {
34373443 // Just leave the padding fields uninitialized...
34383444 // TODO: Or should we initialize them with undef explicitly?
34393445
3440 return try self.load(ty, tmp_id, .{});
3446 // Now cast the pointer and load it as the 'generic' union type.
3447
3448 const casted_var_id = self.spv.allocId();
3449 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3450 .id_result_type = self.typeId(un_general_ptr_ty_ref),
3451 .id_result = casted_var_id,
3452 .operand = tmp_id,
3453 });
3454
3455 const result_id = self.spv.allocId();
3456 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
3457 .id_result_type = self.typeId(un_general_ty_ref),
3458 .id_result = result_id,
3459 .pointer = casted_var_id,
3460 });
3461
3462 return result_id;
34413463 }
34423464
34433465 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
34443466 if (self.liveness.isUnused(inst)) return null;
34453467
3446 const mod = self.module;
3447 const ip = &mod.intern_pool;
34483468 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
34493469 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
34503470 const ty = self.typeOfIndex(inst);
3471 const layout = self.unionLayout(ty, extra.field_index);
34513472
3452 const union_obj = mod.typeToUnion(ty).?;
3453 const field_ty = union_obj.field_types.get(ip)[extra.field_index].toType();
3454 const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(mod))
3473 const payload = if (layout.active_field_size != 0)
34553474 try self.resolve(extra.init)
34563475 else
34573476 null;
......@@ -3480,24 +3499,30 @@ const DeclGen = struct {
34803499 .Union => switch (object_ty.containerLayout(mod)) {
34813500 .Packed => unreachable, // TODO
34823501 else => {
3483 // Store, ptr-elem-ptr, pointer-cast, load
3484 const layout = self.unionLayout(object_ty);
3485 assert(layout.has_payload);
3486
3487 const tmp_id = try self.alloc(object_ty, .{ .storage_class = .Function });
3488 try self.store(object_ty, tmp_id, object_id, .{});
3489
3490 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3491 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3492
3493 const active_pl_ptr_ty_ref = try self.ptrType(field_ty, .Function);
3494 const active_pl_ptr_id = self.spv.allocId();
3502 // Store, pointer-cast, load
3503 const un_general_ty_ref = try self.resolveType(object_ty, .indirect);
3504 const un_general_ptr_ty_ref = try self.spv.ptrType(un_general_ty_ref, .Function);
3505 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);
3506 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, .Function);
3507 const field_ty_ref = try self.resolveType(field_ty, .indirect);
3508 const field_ptr_ty_ref = try self.spv.ptrType(field_ty_ref, .Function);
3509
3510 const tmp_id = self.spv.allocId();
3511 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3512 .id_result_type = self.typeId(un_general_ptr_ty_ref),
3513 .id_result = tmp_id,
3514 .storage_class = .Function,
3515 });
3516 try self.store(object_ty, tmp_id, object_id, false);
3517 const casted_tmp_id = self.spv.allocId();
34953518 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3496 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3497 .id_result = active_pl_ptr_id,
3498 .operand = pl_ptr_id,
3519 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3520 .id_result = casted_tmp_id,
3521 .operand = tmp_id,
34993522 });
3500 return try self.load(field_ty, active_pl_ptr_id, .{});
3523 const layout = self.unionLayout(object_ty, field_index);
3524 const field_ptr_id = try self.accessChain(field_ptr_ty_ref, casted_tmp_id, &.{layout.active_field_index});
3525 return try self.load(field_ty, field_ptr_id, false);
35013526 },
35023527 },
35033528 else => unreachable,
......@@ -3556,24 +3581,18 @@ const DeclGen = struct {
35563581 .Union => switch (object_ty.containerLayout(mod)) {
35573582 .Packed => unreachable, // TODO
35583583 else => {
3559 const layout = self.unionLayout(object_ty);
3560 if (!layout.has_payload) {
3561 // Asked to get a pointer to a zero-sized field. Just lower this
3562 // to undefined, there is no reason to make it be a valid pointer.
3563 return try self.spv.constUndef(result_ty_ref);
3564 }
3565
35663584 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));
3567 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, storage_class);
3568 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, object_ptr, &.{layout.payload_index});
3585 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);
3586 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, storage_class);
35693587
3570 const active_pl_ptr_id = self.spv.allocId();
3588 const casted_id = self.spv.allocId();
35713589 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3572 .id_result_type = self.typeId(result_ty_ref),
3573 .id_result = active_pl_ptr_id,
3574 .operand = pl_ptr_id,
3590 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3591 .id_result = casted_id,
3592 .operand = object_ptr,
35753593 });
3576 return active_pl_ptr_id;
3594 const layout = self.unionLayout(object_ty, field_index);
3595 return try self.accessChain(result_ty_ref, casted_id, &.{layout.active_field_index});
35773596 },
35783597 },
35793598 else => unreachable,
......@@ -3589,13 +3608,23 @@ const DeclGen = struct {
35893608 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);
35903609 }
35913610
3592 const AllocOptions = struct {
3593 initializer: ?IdRef = null,
3594 /// The final storage class of the pointer. This may be either `.Generic` or `.Function`.
3595 /// In either case, the local is allocated in the `.Function` storage class, and optionally
3596 /// cast back to `.Generic`.
3597 storage_class: StorageClass = .Generic,
3598 };
3611 /// We cannot use an OpVariable directly in an OpSpecConstantOp, but we can
3612 /// after we insert a dummy AccessChain...
3613 /// TODO: Get rid of this
3614 fn makePointerConstant(
3615 self: *DeclGen,
3616 section: *SpvSection,
3617 ptr_ty_ref: CacheRef,
3618 ptr_id: IdRef,
3619 ) !IdRef {
3620 const result_id = self.spv.allocId();
3621 try section.emitSpecConstantOp(self.spv.gpa, .OpInBoundsAccessChain, .{
3622 .id_result_type = self.typeId(ptr_ty_ref),
3623 .id_result = result_id,
3624 .base = ptr_id,
3625 });
3626 return result_id;
3627 }
35993628
36003629 // Allocate a function-local variable, with possible initializer.
36013630 // This function returns a pointer to a variable of type `ty_ref`,
......@@ -3603,36 +3632,30 @@ const DeclGen = struct {
36033632 // placed in the Function address space.
36043633 fn alloc(
36053634 self: *DeclGen,
3606 ty: Type,
3607 options: AllocOptions,
3635 ty_ref: CacheRef,
3636 initializer: ?IdRef,
36083637 ) !IdRef {
3609 const ptr_fn_ty_ref = try self.ptrType(ty, .Function);
3638 const fn_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Function);
3639 const general_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Generic);
36103640
36113641 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
36123642 // directly generate them into func.prologue instead of the body.
36133643 const var_id = self.spv.allocId();
36143644 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3615 .id_result_type = self.typeId(ptr_fn_ty_ref),
3645 .id_result_type = self.typeId(fn_ptr_ty_ref),
36163646 .id_result = var_id,
36173647 .storage_class = .Function,
3618 .initializer = options.initializer,
3648 .initializer = initializer,
36193649 });
36203650
3621 switch (options.storage_class) {
3622 .Generic => {
3623 const ptr_gn_ty_ref = try self.ptrType(ty, .Generic);
3624 // Convert to a generic pointer
3625 const result_id = self.spv.allocId();
3626 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
3627 .id_result_type = self.typeId(ptr_gn_ty_ref),
3628 .id_result = result_id,
3629 .pointer = var_id,
3630 });
3631 return result_id;
3632 },
3633 .Function => return var_id,
3634 else => unreachable,
3635 }
3651 // Convert to a generic pointer
3652 const result_id = self.spv.allocId();
3653 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
3654 .id_result_type = self.typeId(general_ptr_ty_ref),
3655 .id_result = result_id,
3656 .pointer = var_id,
3657 });
3658 return result_id;
36363659 }
36373660
36383661 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3641,7 +3664,8 @@ const DeclGen = struct {
36413664 const ptr_ty = self.typeOfIndex(inst);
36423665 assert(ptr_ty.ptrAddressSpace(mod) == .generic);
36433666 const child_ty = ptr_ty.childType(mod);
3644 return try self.alloc(child_ty, .{});
3667 const child_ty_ref = try self.resolveType(child_ty, .indirect);
3668 return try self.alloc(child_ty_ref, null);
36453669 }
36463670
36473671 fn airArg(self: *DeclGen) IdRef {
......@@ -3756,7 +3780,7 @@ const DeclGen = struct {
37563780 const operand = try self.resolve(ty_op.operand);
37573781 if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
37583782
3759 return try self.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3783 return try self.load(elem_ty, operand, ptr_ty.isVolatilePtr(mod));
37603784 }
37613785
37623786 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3766,7 +3790,7 @@ const DeclGen = struct {
37663790 const ptr = try self.resolve(bin_op.lhs);
37673791 const value = try self.resolve(bin_op.rhs);
37683792
3769 try self.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(self.module) });
3793 try self.store(elem_ty, ptr, value, ptr_ty.isVolatilePtr(self.module));
37703794 }
37713795
37723796 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3830,7 +3854,7 @@ const DeclGen = struct {
38303854 }
38313855
38323856 const ptr = try self.resolve(un_op);
3833 const value = try self.load(ret_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
3857 const value = try self.load(ret_ty, ptr, ptr_ty.isVolatilePtr(mod));
38343858 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{
38353859 .value = value,
38363860 });
......@@ -3956,11 +3980,8 @@ const DeclGen = struct {
39563980 members[eu_layout.errorFieldIndex()] = operand_id;
39573981 members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref);
39583982
3959 var types: [2]Type = undefined;
3960 types[eu_layout.errorFieldIndex()] = Type.anyerror;
3961 types[eu_layout.payloadFieldIndex()] = payload_ty;
3962
3963 return try self.constructStruct(err_union_ty, &types, &members);
3983 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
3984 return try self.constructStruct(err_union_ty_ref, &members);
39643985 }
39653986
39663987 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3981,11 +4002,8 @@ const DeclGen = struct {
39814002 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);
39824003 members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id);
39834004
3984 var types: [2]Type = undefined;
3985 types[eu_layout.errorFieldIndex()] = Type.anyerror;
3986 types[eu_layout.payloadFieldIndex()] = payload_ty;
3987
3988 return try self.constructStruct(err_union_ty, &types, &members);
4005 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
4006 return try self.constructStruct(err_union_ty_ref, &members);
39894007 }
39904008
39914009 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
......@@ -4019,7 +4037,7 @@ const DeclGen = struct {
40194037 .is_null => .eq,
40204038 .is_non_null => .neq,
40214039 };
4022 return try self.cmp(op, Type.bool, ptr_ty, ptr_id, null_id);
4040 return try self.cmp(op, ptr_ty, ptr_id, null_id);
40234041 }
40244042
40254043 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
......@@ -4117,10 +4135,10 @@ const DeclGen = struct {
41174135 return operand_id;
41184136 }
41194137
4138 const optional_ty_ref = try self.resolveType(optional_ty, .direct);
41204139 const payload_id = try self.convertToIndirect(payload_ty, operand_id);
41214140 const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };
4122 const types = [_]Type{ payload_ty, Type.bool };
4123 return try self.constructStruct(optional_ty, &types, &members);
4141 return try self.constructStruct(optional_ty_ref, &members);
41244142 }
41254143
41264144 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -4402,7 +4420,6 @@ const DeclGen = struct {
44024420 }
44034421
44044422 // TODO: Multiple results
4405 // TODO: Check that the output type from assembly is the same as the type actually expected by Zig.
44064423 }
44074424
44084425 return null;
src/codegen/spirv/Assembler.zig+4-10
......@@ -304,16 +304,10 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {
304304 // and so some consideration must be taken when entering this in the type system.
305305 return self.todo("process OpTypeArray", .{});
306306 },
307 .OpTypePointer => blk: {
308 break :blk try self.spv.resolve(.{
309 .ptr_type = .{
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 },
307 .OpTypePointer => try self.spv.ptrType(
308 try self.resolveTypeRef(operands[2].ref_id),
309 @as(spec.StorageClass, @enumFromInt(operands[1].value)),
310 ),
317311 .OpTypeFunction => blk: {
318312 const param_operands = operands[2..];
319313 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);
src/codegen/spirv/Cache.zig+124-182
......@@ -22,8 +22,6 @@ const Opcode = spec.Opcode;
2222const IdResult = spec.IdResult;
2323const StorageClass = spec.StorageClass;
2424
25const InternPool = @import("../../InternPool.zig");
26
2725const Self = @This();
2826
2927map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
......@@ -33,8 +31,6 @@ extra: std.ArrayListUnmanaged(u32) = .{},
3331string_bytes: std.ArrayListUnmanaged(u8) = .{},
3432strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},
3533
36recursive_ptrs: std.AutoHashMapUnmanaged(Ref, void) = .{},
37
3834const Item = struct {
3935 tag: Tag,
4036 /// The result-id that this item uses.
......@@ -66,21 +62,18 @@ const Tag = enum {
6662 /// Function (proto)type
6763 /// data is payload to FunctionType
6864 type_function,
69 // /// Pointer type in the CrossWorkgroup storage class
70 // /// data is child type
71 // type_ptr_generic,
72 // /// Pointer type in the CrossWorkgroup storage class
73 // /// data is child type
74 // type_ptr_crosswgp,
75 // /// Pointer type in the Function storage class
76 // /// data is child type
77 // type_ptr_function,
65 /// Pointer type in the CrossWorkgroup storage class
66 /// data is child type
67 type_ptr_generic,
68 /// Pointer type in the CrossWorkgroup storage class
69 /// data is child type
70 type_ptr_crosswgp,
71 /// Pointer type in the Function storage class
72 /// data is child type
73 type_ptr_function,
7874 /// Simple pointer type that does not have any decorations.
7975 /// data is payload to SimplePointerType
8076 type_ptr_simple,
81 /// A forward declaration for a pointer.
82 /// data is ForwardPointerType
83 type_fwd_ptr,
8477 /// Simple structure type that does not have any decorations.
8578 /// data is payload to SimpleStructType
8679 type_struct_simple,
......@@ -149,12 +142,6 @@ const Tag = enum {
149142 const SimplePointerType = struct {
150143 storage_class: StorageClass,
151144 child_type: Ref,
152 fwd: Ref,
153 };
154
155 const ForwardPointerType = struct {
156 storage_class: StorageClass,
157 zig_child_type: InternPool.Index,
158145 };
159146
160147 /// Trailing:
......@@ -176,14 +163,14 @@ const Tag = enum {
176163 fn encode(value: f64) Float64 {
177164 const bits = @as(u64, @bitCast(value));
178165 return .{
179 .low = @truncate(bits),
180 .high = @truncate(bits >> 32),
166 .low = @as(u32, @truncate(bits)),
167 .high = @as(u32, @truncate(bits >> 32)),
181168 };
182169 }
183170
184171 fn decode(self: Float64) f64 {
185172 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);
186 return @bitCast(bits);
173 return @as(f64, @bitCast(bits));
187174 }
188175 };
189176
......@@ -205,8 +192,8 @@ const Tag = enum {
205192 fn encode(ty: Ref, value: u64) Int64 {
206193 return .{
207194 .ty = ty,
208 .low = @truncate(value),
209 .high = @truncate(value >> 32),
195 .low = @as(u32, @truncate(value)),
196 .high = @as(u32, @truncate(value >> 32)),
210197 };
211198 }
212199
......@@ -223,8 +210,8 @@ const Tag = enum {
223210 fn encode(ty: Ref, value: i64) Int64 {
224211 return .{
225212 .ty = ty,
226 .low = @truncate(@as(u64, @bitCast(value))),
227 .high = @truncate(@as(u64, @bitCast(value)) >> 32),
213 .low = @as(u32, @truncate(@as(u64, @bitCast(value)))),
214 .high = @as(u32, @truncate(@as(u64, @bitCast(value)) >> 32)),
228215 };
229216 }
230217
......@@ -250,7 +237,6 @@ pub const Key = union(enum) {
250237 array_type: ArrayType,
251238 function_type: FunctionType,
252239 ptr_type: PointerType,
253 fwd_ptr_type: ForwardPointerType,
254240 struct_type: StructType,
255241 opaque_type: OpaqueType,
256242
......@@ -287,18 +273,12 @@ pub const Key = union(enum) {
287273 pub const PointerType = struct {
288274 storage_class: StorageClass,
289275 child_type: Ref,
290 fwd: Ref,
291276 // TODO: Decorations:
292277 // - Alignment
293278 // - ArrayStride,
294279 // - MaxByteOffset,
295280 };
296281
297 pub const ForwardPointerType = struct {
298 zig_child_type: InternPool.Index,
299 storage_class: StorageClass,
300 };
301
302282 pub const StructType = struct {
303283 // TODO: Decorations.
304284 /// The name of the structure. Can be `.none`.
......@@ -333,21 +313,21 @@ pub const Key = union(enum) {
333313 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.
334314 fn toBits32(self: Int) u32 {
335315 return switch (self.value) {
336 .uint64 => |val| @intCast(val),
337 .int64 => |val| if (val < 0) @bitCast(@as(i32, @intCast(val))) else @intCast(val),
316 .uint64 => |val| @as(u32, @intCast(val)),
317 .int64 => |val| if (val < 0) @as(u32, @bitCast(@as(i32, @intCast(val)))) else @as(u32, @intCast(val)),
338318 };
339319 }
340320
341321 fn toBits64(self: Int) u64 {
342322 return switch (self.value) {
343323 .uint64 => |val| val,
344 .int64 => |val| @bitCast(val),
324 .int64 => |val| @as(u64, @bitCast(val)),
345325 };
346326 }
347327
348328 fn to(self: Int, comptime T: type) T {
349329 return switch (self.value) {
350 inline else => |val| @intCast(val),
330 inline else => |val| @as(T, @intCast(val)),
351331 };
352332 }
353333 };
......@@ -407,7 +387,7 @@ pub const Key = union(enum) {
407387 },
408388 inline else => |key| std.hash.autoHash(&hasher, key),
409389 }
410 return @truncate(hasher.final());
390 return @as(u32, @truncate(hasher.final()));
411391 }
412392
413393 fn eql(a: Key, b: Key) bool {
......@@ -439,7 +419,7 @@ pub const Key = union(enum) {
439419
440420 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {
441421 _ = b_void;
442 return ctx.self.lookup(@enumFromInt(b_index)).eql(a);
422 return ctx.self.lookup(@as(Ref, @enumFromInt(b_index))).eql(a);
443423 }
444424
445425 pub fn hash(ctx: @This(), a: Key) u32 {
......@@ -470,7 +450,6 @@ pub fn deinit(self: *Self, spv: *const Module) void {
470450 self.extra.deinit(spv.gpa);
471451 self.string_bytes.deinit(spv.gpa);
472452 self.strings.deinit(spv.gpa);
473 self.recursive_ptrs.deinit(spv.gpa);
474453}
475454
476455/// Actually materialize the database into spir-v instructions.
......@@ -481,7 +460,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {
481460 var section = Section{};
482461 errdefer section.deinit(spv.gpa);
483462 for (self.items.items(.result_id), 0..) |result_id, index| {
484 try self.emit(spv, result_id, @enumFromInt(index), &section);
463 try self.emit(spv, result_id, @as(Ref, @enumFromInt(index)), &section);
485464 }
486465 return section;
487466}
......@@ -559,15 +538,6 @@ fn emit(
559538 });
560539 // TODO: Decorations?
561540 },
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 },
571541 .struct_type => |struct_type| {
572542 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);
573543 section.writeOperand(IdResult, result_id);
......@@ -579,7 +549,7 @@ fn emit(
579549 }
580550 for (struct_type.memberNames(), 0..) |member_name, i| {
581551 if (self.getString(member_name)) |name| {
582 try spv.memberDebugName(result_id, @intCast(i), name);
552 try spv.memberDebugName(result_id, @as(u32, @intCast(i)), name);
583553 }
584554 }
585555 // TODO: Decorations?
......@@ -655,12 +625,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
655625 const adapter: Key.Adapter = .{ .self = self };
656626 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);
657627 if (entry.found_existing) {
658 return @enumFromInt(entry.index);
628 return @as(Ref, @enumFromInt(entry.index));
659629 }
630 const result_id = spv.allocId();
660631 const item: Item = switch (key) {
661632 inline .void_type, .bool_type => .{
662633 .tag = .type_simple,
663 .result_id = spv.allocId(),
634 .result_id = result_id,
664635 .data = @intFromEnum(key.toSimpleType()),
665636 },
666637 .int_type => |int| blk: {
......@@ -670,104 +641,87 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
670641 };
671642 break :blk .{
672643 .tag = t,
673 .result_id = spv.allocId(),
644 .result_id = result_id,
674645 .data = int.bits,
675646 };
676647 },
677648 .float_type => |float| .{
678649 .tag = .type_float,
679 .result_id = spv.allocId(),
650 .result_id = result_id,
680651 .data = float.bits,
681652 },
682653 .vector_type => |vector| .{
683654 .tag = .type_vector,
684 .result_id = spv.allocId(),
655 .result_id = result_id,
685656 .data = try self.addExtra(spv, vector),
686657 },
687658 .array_type => |array| .{
688659 .tag = .type_array,
689 .result_id = spv.allocId(),
660 .result_id = result_id,
690661 .data = try self.addExtra(spv, array),
691662 },
692663 .function_type => |function| blk: {
693664 const extra = try self.addExtra(spv, Tag.FunctionType{
694 .param_len = @intCast(function.parameters.len),
665 .param_len = @as(u32, @intCast(function.parameters.len)),
695666 .return_type = function.return_type,
696667 });
697 try self.extra.appendSlice(spv.gpa, @ptrCast(function.parameters));
668 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(function.parameters)));
698669 break :blk .{
699670 .tag = .type_function,
700 .result_id = spv.allocId(),
671 .result_id = result_id,
701672 .data = extra,
702673 };
703674 },
704 // .ptr_type => |ptr| switch (ptr.storage_class) {
705 // .Generic => Item{
706 // .tag = .type_ptr_generic,
707 // .result_id = spv.allocId(),
708 // .data = @intFromEnum(ptr.child_type),
709 // },
710 // .CrossWorkgroup => Item{
711 // .tag = .type_ptr_crosswgp,
712 // .result_id = spv.allocId(),
713 // .data = @intFromEnum(ptr.child_type),
714 // },
715 // .Function => Item{
716 // .tag = .type_ptr_function,
717 // .result_id = spv.allocId(),
718 // .data = @intFromEnum(ptr.child_type),
719 // },
720 // else => |storage_class| Item{
721 // .tag = .type_ptr_simple,
722 // .result_id = spv.allocId(),
723 // .data = try self.addExtra(spv, Tag.SimplePointerType{
724 // .storage_class = storage_class,
725 // .child_type = ptr.child_type,
726 // }),
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 }),
675 .ptr_type => |ptr| switch (ptr.storage_class) {
676 .Generic => Item{
677 .tag = .type_ptr_generic,
678 .result_id = result_id,
679 .data = @intFromEnum(ptr.child_type),
680 },
681 .CrossWorkgroup => Item{
682 .tag = .type_ptr_crosswgp,
683 .result_id = result_id,
684 .data = @intFromEnum(ptr.child_type),
685 },
686 .Function => Item{
687 .tag = .type_ptr_function,
688 .result_id = result_id,
689 .data = @intFromEnum(ptr.child_type),
690 },
691 else => |storage_class| Item{
692 .tag = .type_ptr_simple,
693 .result_id = result_id,
694 .data = try self.addExtra(spv, Tag.SimplePointerType{
695 .storage_class = storage_class,
696 .child_type = ptr.child_type,
697 }),
698 },
745699 },
746700 .struct_type => |struct_type| blk: {
747701 const extra = try self.addExtra(spv, Tag.SimpleStructType{
748702 .name = struct_type.name,
749 .members_len = @intCast(struct_type.member_types.len),
703 .members_len = @as(u32, @intCast(struct_type.member_types.len)),
750704 });
751 try self.extra.appendSlice(spv.gpa, @ptrCast(struct_type.member_types));
705 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(struct_type.member_types)));
752706
753707 if (struct_type.member_names) |member_names| {
754 try self.extra.appendSlice(spv.gpa, @ptrCast(member_names));
708 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(member_names)));
755709 break :blk Item{
756710 .tag = .type_struct_simple_with_member_names,
757 .result_id = spv.allocId(),
711 .result_id = result_id,
758712 .data = extra,
759713 };
760714 } else {
761715 break :blk Item{
762716 .tag = .type_struct_simple,
763 .result_id = spv.allocId(),
717 .result_id = result_id,
764718 .data = extra,
765719 };
766720 }
767721 },
768722 .opaque_type => |opaque_type| Item{
769723 .tag = .type_opaque,
770 .result_id = spv.allocId(),
724 .result_id = result_id,
771725 .data = @intFromEnum(opaque_type.name),
772726 },
773727 .int => |int| blk: {
......@@ -775,13 +729,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
775729 if (int_type.signedness == .unsigned and int_type.bits == 8) {
776730 break :blk .{
777731 .tag = .uint8,
778 .result_id = spv.allocId(),
732 .result_id = result_id,
779733 .data = int.to(u8),
780734 };
781735 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {
782736 break :blk .{
783737 .tag = .uint32,
784 .result_id = spv.allocId(),
738 .result_id = result_id,
785739 .data = int.to(u32),
786740 };
787741 }
......@@ -791,32 +745,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
791745 if (val >= 0 and val <= std.math.maxInt(u32)) {
792746 break :blk .{
793747 .tag = .uint_small,
794 .result_id = spv.allocId(),
748 .result_id = result_id,
795749 .data = try self.addExtra(spv, Tag.UInt32{
796750 .ty = int.ty,
797 .value = @intCast(val),
751 .value = @as(u32, @intCast(val)),
798752 }),
799753 };
800754 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {
801755 break :blk .{
802756 .tag = .int_small,
803 .result_id = spv.allocId(),
757 .result_id = result_id,
804758 .data = try self.addExtra(spv, Tag.Int32{
805759 .ty = int.ty,
806 .value = @intCast(val),
760 .value = @as(i32, @intCast(val)),
807761 }),
808762 };
809763 } else if (val < 0) {
810764 break :blk .{
811765 .tag = .int_large,
812 .result_id = spv.allocId(),
813 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @intCast(val))),
766 .result_id = result_id,
767 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @as(i64, @intCast(val)))),
814768 };
815769 } else {
816770 break :blk .{
817771 .tag = .uint_large,
818 .result_id = spv.allocId(),
819 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @intCast(val))),
772 .result_id = result_id,
773 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @as(u64, @intCast(val)))),
820774 };
821775 }
822776 },
......@@ -825,29 +779,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
825779 .float => |float| switch (self.lookup(float.ty).float_type.bits) {
826780 16 => .{
827781 .tag = .float16,
828 .result_id = spv.allocId(),
782 .result_id = result_id,
829783 .data = @as(u16, @bitCast(float.value.float16)),
830784 },
831785 32 => .{
832786 .tag = .float32,
833 .result_id = spv.allocId(),
787 .result_id = result_id,
834788 .data = @as(u32, @bitCast(float.value.float32)),
835789 },
836790 64 => .{
837791 .tag = .float64,
838 .result_id = spv.allocId(),
792 .result_id = result_id,
839793 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),
840794 },
841795 else => unreachable,
842796 },
843797 .undef => |undef| .{
844798 .tag = .undef,
845 .result_id = spv.allocId(),
799 .result_id = result_id,
846800 .data = @intFromEnum(undef.ty),
847801 },
848802 .null => |null_info| .{
849803 .tag = .null,
850 .result_id = spv.allocId(),
804 .result_id = result_id,
851805 .data = @intFromEnum(null_info.ty),
852806 },
853807 .bool => |bool_info| .{
......@@ -855,13 +809,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
855809 true => Tag.bool_true,
856810 false => Tag.bool_false,
857811 },
858 .result_id = spv.allocId(),
812 .result_id = result_id,
859813 .data = @intFromEnum(bool_info.ty),
860814 },
861815 };
862816 try self.items.append(spv.gpa, item);
863817
864 return @enumFromInt(entry.index);
818 return @as(Ref, @enumFromInt(entry.index));
865819}
866820
867821/// Turn a Ref back into a Key.
......@@ -876,14 +830,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
876830 },
877831 .type_int_signed => .{ .int_type = .{
878832 .signedness = .signed,
879 .bits = @intCast(data),
833 .bits = @as(u16, @intCast(data)),
880834 } },
881835 .type_int_unsigned => .{ .int_type = .{
882836 .signedness = .unsigned,
883 .bits = @intCast(data),
837 .bits = @as(u16, @intCast(data)),
884838 } },
885839 .type_float => .{ .float_type = .{
886 .bits = @intCast(data),
840 .bits = @as(u16, @intCast(data)),
887841 } },
888842 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },
889843 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },
......@@ -892,50 +846,40 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
892846 return .{
893847 .function_type = .{
894848 .return_type = payload.data.return_type,
895 .parameters = @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len]),
849 .parameters = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len])),
896850 },
897851 };
898852 },
899 // .type_ptr_generic => .{
900 // .ptr_type = .{
901 // .storage_class = .Generic,
902 // .child_type = @enumFromInt(data),
903 // },
904 // },
905 // .type_ptr_crosswgp => .{
906 // .ptr_type = .{
907 // .storage_class = .CrossWorkgroup,
908 // .child_type = @enumFromInt(data),
909 // },
910 // },
911 // .type_ptr_function => .{
912 // .ptr_type = .{
913 // .storage_class = .Function,
914 // .child_type = @enumFromInt(data),
915 // },
916 // },
853 .type_ptr_generic => .{
854 .ptr_type = .{
855 .storage_class = .Generic,
856 .child_type = @as(Ref, @enumFromInt(data)),
857 },
858 },
859 .type_ptr_crosswgp => .{
860 .ptr_type = .{
861 .storage_class = .CrossWorkgroup,
862 .child_type = @as(Ref, @enumFromInt(data)),
863 },
864 },
865 .type_ptr_function => .{
866 .ptr_type = .{
867 .storage_class = .Function,
868 .child_type = @as(Ref, @enumFromInt(data)),
869 },
870 },
917871 .type_ptr_simple => {
918872 const payload = self.extraData(Tag.SimplePointerType, data);
919873 return .{
920874 .ptr_type = .{
921875 .storage_class = payload.storage_class,
922876 .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,
933877 },
934878 };
935879 },
936880 .type_struct_simple => {
937881 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
938 const member_types: []const Ref = @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]);
882 const member_types = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]));
939883 return .{
940884 .struct_type = .{
941885 .name = payload.data.name,
......@@ -947,8 +891,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
947891 .type_struct_simple_with_member_names => {
948892 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
949893 const trailing = self.extra.items[payload.trail..];
950 const member_types: []const Ref = @ptrCast(trailing[0..payload.data.members_len]);
951 const member_names: []const String = @ptrCast(trailing[payload.data.members_len..][0..payload.data.members_len]);
894 const member_types = @as([]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]));
952896 return .{
953897 .struct_type = .{
954898 .name = payload.data.name,
......@@ -959,16 +903,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
959903 },
960904 .type_opaque => .{
961905 .opaque_type = .{
962 .name = @enumFromInt(data),
906 .name = @as(String, @enumFromInt(data)),
963907 },
964908 },
965909 .float16 => .{ .float = .{
966910 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),
967 .value = .{ .float16 = @bitCast(@as(u16, @intCast(data))) },
911 .value = .{ .float16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },
968912 } },
969913 .float32 => .{ .float = .{
970914 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),
971 .value = .{ .float32 = @bitCast(data) },
915 .value = .{ .float32 = @as(f32, @bitCast(data)) },
972916 } },
973917 .float64 => .{ .float = .{
974918 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),
......@@ -1011,17 +955,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
1011955 } };
1012956 },
1013957 .undef => .{ .undef = .{
1014 .ty = @enumFromInt(data),
958 .ty = @as(Ref, @enumFromInt(data)),
1015959 } },
1016960 .null => .{ .null = .{
1017 .ty = @enumFromInt(data),
961 .ty = @as(Ref, @enumFromInt(data)),
1018962 } },
1019963 .bool_true => .{ .bool = .{
1020 .ty = @enumFromInt(data),
964 .ty = @as(Ref, @enumFromInt(data)),
1021965 .value = true,
1022966 } },
1023967 .bool_false => .{ .bool = .{
1024 .ty = @enumFromInt(data),
968 .ty = @as(Ref, @enumFromInt(data)),
1025969 .value = false,
1026970 } },
1027971 };
......@@ -1037,7 +981,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {
1037981fn get(self: *const Self, key: Key) Ref {
1038982 const adapter: Key.Adapter = .{ .self = self };
1039983 const index = self.map.getIndexAdapted(key, adapter).?;
1040 return @enumFromInt(index);
984 return @as(Ref, @enumFromInt(index));
1041985}
1042986
1043987fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
......@@ -1047,16 +991,15 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
1047991}
1048992
1049993fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {
1050 const payload_offset: u32 = @intCast(self.extra.items.len);
994 const payload_offset = @as(u32, @intCast(self.extra.items.len));
1051995 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
1052996 const field_val = @field(extra, field.name);
1053 const word: u32 = switch (field.type) {
997 const word = switch (field.type) {
1054998 u32 => field_val,
1055 i32 => @bitCast(field_val),
999 i32 => @as(u32, @bitCast(field_val)),
10561000 Ref => @intFromEnum(field_val),
10571001 StorageClass => @intFromEnum(field_val),
10581002 String => @intFromEnum(field_val),
1059 InternPool.Index => @intFromEnum(field_val),
10601003 else => @compileError("Invalid type: " ++ @typeName(field.type)),
10611004 };
10621005 self.extra.appendAssumeCapacity(word);
......@@ -1075,11 +1018,10 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t
10751018 const word = self.extra.items[offset + i];
10761019 @field(result, field.name) = switch (field.type) {
10771020 u32 => word,
1078 i32 => @bitCast(word),
1079 Ref => @enumFromInt(word),
1080 StorageClass => @enumFromInt(word),
1081 String => @enumFromInt(word),
1082 InternPool.Index => @enumFromInt(word),
1021 i32 => @as(i32, @bitCast(word)),
1022 Ref => @as(Ref, @enumFromInt(word)),
1023 StorageClass => @as(StorageClass, @enumFromInt(word)),
1024 String => @as(String, @enumFromInt(word)),
10831025 else => @compileError("Invalid type: " ++ @typeName(field.type)),
10841026 };
10851027 }
......@@ -1107,7 +1049,7 @@ pub const String = enum(u32) {
11071049 _ = ctx;
11081050 var hasher = std.hash.Wyhash.init(0);
11091051 hasher.update(a);
1110 return @truncate(hasher.final());
1052 return @as(u32, @truncate(hasher.final()));
11111053 }
11121054 };
11131055};
......@@ -1122,10 +1064,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {
11221064 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);
11231065 self.string_bytes.appendSliceAssumeCapacity(str);
11241066 self.string_bytes.appendAssumeCapacity(0);
1125 entry.value_ptr.* = @intCast(offset);
1067 entry.value_ptr.* = @as(u32, @intCast(offset));
11261068 }
11271069
1128 return @enumFromInt(entry.index);
1070 return @as(String, @enumFromInt(entry.index));
11291071}
11301072
11311073pub fn getString(self: *const Self, ref: String) ?[]const u8 {
src/codegen/spirv/Module.zig+11
......@@ -507,6 +507,17 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {
507507 } });
508508}
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
510521pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {
511522 const ty = self.cache.lookup(ty_ref).int_type;
512523 const Value = Cache.Key.Int.Value;
test/behavior/bugs/12000.zig+1
......@@ -9,6 +9,7 @@ test {
99 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1111 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1213
1314 var t: T = .{ .next = null };
1415 try std.testing.expect(t.next == null);
test/behavior/bugs/1735.zig+1
......@@ -44,6 +44,7 @@ const a = struct {
4444test "initialization" {
4545 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4646 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
4748
4849 var t = a.init();
4950 try std.testing.expect(t.foo.len == 0);
test/behavior/bugs/1914.zig+4
......@@ -12,6 +12,8 @@ const b_list: []B = &[_]B{};
1212const a = A{ .b_list_pointer = &b_list };
1313
1414test "segfault bug" {
15 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16
1517 const assert = std.debug.assert;
1618 const obj = B{ .a_pointer = &a };
1719 assert(obj.a_pointer == &a); // this makes zig crash
......@@ -28,5 +30,7 @@ pub const B2 = struct {
2830var b_value = B2{ .pointer_array = &[_]*A2{} };
2931
3032test "basic stuff" {
33 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34
3135 std.debug.assert(&b_value == &b_value);
3236}
test/behavior/bugs/2006.zig+1
......@@ -7,6 +7,7 @@ const S = struct {
77};
88test "bug 2006" {
99 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1011
1112 var a: S = undefined;
1213 a = S{ .p = undefined };
test/behavior/bugs/3007.zig+1
......@@ -22,6 +22,7 @@ test "fixed" {
2222 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2323 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2424 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2526
2627 default_foo = get_foo() catch null; // This Line
2728 try std.testing.expect(!default_foo.?.free);
test/behavior/bugs/6947.zig+1
......@@ -8,6 +8,7 @@ test {
88 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
99 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1010 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1112
1213 var slice: []void = undefined;
1314 destroy(&slice[0]);
test/behavior/bugs/7325.zig+1
......@@ -81,6 +81,7 @@ test {
8181 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
8282 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8383 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8485
8586 var param: ParamType = .{
8687 .one_of = .{ .name = "name" },
test/behavior/error.zig+1
......@@ -943,6 +943,7 @@ test "returning an error union containing a type with no runtime bits" {
943943test "try used in recursive function with inferred error set" {
944944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
945945 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
946 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
946947
947948 const Value = union(enum) {
948949 values: []const @This(),
test/behavior/eval.zig+4
......@@ -391,6 +391,7 @@ test "return 0 from function that has u0 return type" {
391391test "statically initialized struct" {
392392 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
393393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
394 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
394395
395396 st_init_str_foo.x += 1;
396397 try expect(st_init_str_foo.x == 14);
......@@ -497,6 +498,7 @@ test "comptime shlWithOverflow" {
497498test "const ptr to variable data changes at runtime" {
498499 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
499500 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
500502
501503 try expect(foo_ref.name[0] == 'a');
502504 foo_ref.name = "b";
......@@ -1549,6 +1551,8 @@ test "comptime function turns function value to function pointer" {
15491551}
15501552
15511553test "container level const and var have unique addresses" {
1554 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1555
15521556 const S = struct {
15531557 x: i32,
15541558 y: i32,
test/behavior/generics.zig+1
......@@ -205,6 +205,7 @@ fn foo2(arg: anytype) bool {
205205
206206test "generic struct" {
207207 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
208 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
208209
209210 var a1 = GenNode(i32){
210211 .value = 13,
test/behavior/null.zig+1
......@@ -185,6 +185,7 @@ test "unwrap optional which is field of global var" {
185185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
186186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
187187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
188189
189190 struct_with_optional.field = null;
190191 if (struct_with_optional.field) |payload| {
test/behavior/optional.zig+1
......@@ -193,6 +193,7 @@ test "nested orelse" {
193193test "self-referential struct through a slice of optional" {
194194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
196197
197198 const S = struct {
198199 const Node = struct {
test/behavior/ptrcast.zig+2
......@@ -130,6 +130,7 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
130130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
131131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
132132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
133134
134135 // Test lowering a field ptr
135136 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
......@@ -152,6 +153,7 @@ test "lower reinterpreted comptime field ptr" {
152153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
153154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
155157
156158 // Test lowering a field ptr
157159 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
test/behavior/struct.zig+6
......@@ -292,6 +292,7 @@ const Val = struct {
292292test "struct point to self" {
293293 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
294294 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
295296
296297 var root: Node = undefined;
297298 root.val.x = 1;
......@@ -346,6 +347,7 @@ test "self-referencing struct via array member" {
346347 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
347348 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
348349 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
349351
350352 const T = struct {
351353 children: [1]*@This(),
......@@ -368,6 +370,7 @@ const EmptyStruct = struct {
368370
369371test "align 1 field before self referential align 8 field as slice return type" {
370372 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
371374
372375 const result = alloc(Expr);
373376 try expect(result.len == 0);
......@@ -733,6 +736,7 @@ test "packed struct with u0 field access" {
733736test "access to global struct fields" {
734737 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
735738 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
736740
737741 g_foo.bar.value = 42;
738742 try expect(g_foo.bar.value == 42);
......@@ -1419,6 +1423,7 @@ test "fieldParentPtr of a zero-bit field" {
14191423
14201424test "struct field has a pointer to an aligned version of itself" {
14211425 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1426 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14221427
14231428 const E = struct {
14241429 next: *align(1) @This(),
......@@ -1514,6 +1519,7 @@ test "function pointer in struct returns the struct" {
15141519
15151520test "no dependency loop on optional field wrapped in generic function" {
15161521 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1522 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15171523
15181524 const S = struct {
15191525 fn Atomic(comptime T: type) type {
test/behavior/struct_contains_null_ptr_itself.zig+1
......@@ -5,6 +5,7 @@ const builtin = @import("builtin");
55test "struct contains null pointer which contains original struct" {
66 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
77 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
89
910 var x: ?*NodeLineComment = null;
1011 try expect(x == null);
test/behavior/struct_contains_slice_of_itself.zig+2
......@@ -13,6 +13,7 @@ const NodeAligned = struct {
1313
1414test "struct contains slice of itself" {
1515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1617
1718 var other_nodes = [_]Node{
1819 Node{
......@@ -53,6 +54,7 @@ test "struct contains slice of itself" {
5354test "struct contains aligned slice of itself" {
5455 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5556 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5658
5759 var other_nodes = [_]NodeAligned{
5860 NodeAligned{
test/behavior/union.zig+10
......@@ -399,6 +399,7 @@ test "tagged union with no payloads" {
399399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
400400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
401401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
402403
403404 const a = UnionEnumNoPayloads{ .B = {} };
404405 switch (a) {
......@@ -473,6 +474,7 @@ test "update the tag value for zero-sized unions" {
473474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
474475 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
475476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
476478
477479 const S = union(enum) {
478480 U0: void,
......@@ -513,6 +515,7 @@ test "method call on an empty union" {
513515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
514516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
515517 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
516519
517520 const S = struct {
518521 const MyUnion = union(MyUnionTag) {
......@@ -590,6 +593,7 @@ test "tagged union with all void fields but a meaningful tag" {
590593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
591594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
592595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
593597
594598 const S = struct {
595599 const B = union(enum) {
......@@ -791,6 +795,7 @@ test "@unionInit stored to a const" {
791795 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
792796 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
793797 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
798 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
794799
795800 const S = struct {
796801 const U = union(enum) {
......@@ -862,6 +867,7 @@ test "union no tag with struct member" {
862867 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
863868 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
864869 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
870 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
865871
866872 const Struct = struct {};
867873 const Union = union {
......@@ -1073,6 +1079,7 @@ test "@unionInit on union with tag but no fields" {
10731079 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10741080 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10751081 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1082 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10761083
10771084 const S = struct {
10781085 const Type = enum(u8) { no_op = 105 };
......@@ -1121,6 +1128,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
11211128 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11221129 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11231130 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1131 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11241132
11251133 const T = struct {
11261134 const U = union(enum) {
......@@ -1340,6 +1348,7 @@ test "union field ptr - zero sized payload" {
13401348 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13411349 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13421350 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1351 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13431352
13441353 const U = union {
13451354 foo: void,
......@@ -1354,6 +1363,7 @@ test "union field ptr - zero sized field" {
13541363 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13551364 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13561365 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1366 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13571367
13581368 const U = union {
13591369 foo: void,