authorgravatar for robin@voetter.nlRobin Voetter <robin@voetter.nl> 2023-10-22 15:35:00+02:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-10-22 15:35:00+02:00
logb822e841cda0adabe3fec260ff51c18508f7ee32
treefe1bdf51d000cddcf4b42a20f3c69111c16651d8
parent0c99ba1eab63865592bb084feb271cd4e4b0357e
parent6281ad91dfc0d799bfabced68009dfb4971545d7
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

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

spirv: recursive pointers

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

src/codegen/spirv.zig+292-309
......@@ -209,6 +209,10 @@ 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
212216 /// We need to keep track of result ids for block labels, as well as the 'incoming'
213217 /// blocks for a block.
214218 blocks: BlockMap = .{},
......@@ -295,6 +299,7 @@ const DeclGen = struct {
295299 pub fn deinit(self: *DeclGen) void {
296300 self.args.deinit(self.gpa);
297301 self.inst_results.deinit(self.gpa);
302 self.wip_pointers.deinit(self.gpa);
298303 self.blocks.deinit(self.gpa);
299304 self.func.deinit(self.gpa);
300305 self.base_line_stack.deinit(self.gpa);
......@@ -358,8 +363,7 @@ const DeclGen = struct {
358363
359364 const mod = self.module;
360365 const ty = mod.intern_pool.typeOf(val).toType();
361 const ty_ref = try self.resolveType(ty, .indirect);
362 const ptr_ty_ref = try self.spv.ptrType(ty_ref, storage_class);
366 const ptr_ty_ref = try self.ptrType(ty, storage_class);
363367
364368 const var_id = self.spv.declPtr(spv_decl_index).result_id;
365369
......@@ -582,66 +586,41 @@ const DeclGen = struct {
582586 }
583587
584588 /// Construct a struct at runtime.
585 /// result_ty_ref must be a struct type.
589 /// ty must be a struct type.
586590 /// Constituents should be in `indirect` representation (as the elements of a struct should be).
587591 /// Result is in `direct` representation.
588 fn constructStruct(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {
592 fn constructStruct(self: *DeclGen, ty: Type, types: []const Type, constituents: []const IdRef) !IdRef {
593 assert(types.len == constituents.len);
589594 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
590595 // operands are not constant.
591596 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
592597 // For now, just initialize the struct by setting the fields manually...
593598 // TODO: Make this OpCompositeConstruct when we can
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);
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);
607602 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
608603 try self.func.body.emit(self.spv.gpa, .OpStore, .{
609604 .pointer = ptr_id,
610605 .object = constitent_id,
611606 });
612607 }
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;
608 return try self.load(ty, ptr_composite_id, .{});
620609 }
621610
622611 /// Construct an array at runtime.
623 /// result_ty_ref must be an array type.
612 /// ty must be an array type.
624613 /// Constituents should be in `indirect` representation (as the elements of an array should be).
625614 /// Result is in `direct` representation.
626 fn constructArray(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {
615 fn constructArray(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef {
627616 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
628617 // operands are not constant.
629618 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
630619 // For now, just initialize the struct by setting the fields manually...
631620 // TODO: Make this OpCompositeConstruct when we can
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
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);
645624 for (constituents, 0..) |constitent_id, index| {
646625 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
647626 try self.func.body.emit(self.spv.gpa, .OpStore, .{
......@@ -649,13 +628,8 @@ const DeclGen = struct {
649628 .object = constitent_id,
650629 });
651630 }
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;
631
632 return try self.load(ty, ptr_composite_id, .{});
659633 }
660634
661635 /// This function generates a load for a constant in direct (ie, non-memory) representation.
......@@ -766,15 +740,18 @@ const DeclGen = struct {
766740 }.toValue();
767741
768742 var constituents: [2]IdRef = undefined;
743 var types: [2]Type = undefined;
769744 if (eu_layout.error_first) {
770745 constituents[0] = try self.constant(err_ty, err_val, .indirect);
771746 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);
747 types = .{ err_ty, payload_ty };
772748 } else {
773749 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);
774750 constituents[1] = try self.constant(err_ty, err_val, .indirect);
751 types = .{ payload_ty, err_ty };
775752 }
776753
777 return try self.constructStruct(result_ty_ref, &constituents);
754 return try self.constructStruct(ty, &types, &constituents);
778755 },
779756 .enum_tag => {
780757 const int_val = try val.intFromEnum(ty, mod);
......@@ -792,7 +769,11 @@ const DeclGen = struct {
792769 }
793770
794771 const len_id = try self.constant(Type.usize, ptr.len.toValue(), .indirect);
795 return try self.constructStruct(result_ty_ref, &.{ ptr_id, len_id });
772 return try self.constructStruct(
773 ty,
774 &.{ ptr_ty, Type.usize },
775 &.{ ptr_id, len_id },
776 );
796777 },
797778 .opt => {
798779 const payload_ty = ty.optionalChild(mod);
......@@ -819,7 +800,11 @@ const DeclGen = struct {
819800 else
820801 try self.spv.constUndef(try self.resolveType(payload_ty, .indirect));
821802
822 return try self.constructStruct(result_ty_ref, &.{ payload_id, has_pl_id });
803 return try self.constructStruct(
804 ty,
805 &.{ payload_ty, Type.bool },
806 &.{ payload_id, has_pl_id },
807 );
823808 },
824809 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {
825810 inline .array_type, .vector_type => |array_type, tag| {
......@@ -857,7 +842,7 @@ const DeclGen = struct {
857842 else => {},
858843 }
859844
860 return try self.constructArray(result_ty_ref, constituents);
845 return try self.constructArray(ty, constituents);
861846 },
862847 .struct_type => {
863848 const struct_type = mod.typeToStruct(ty).?;
......@@ -865,6 +850,9 @@ const DeclGen = struct {
865850 return self.todo("packed struct constants", .{});
866851 }
867852
853 var types = std.ArrayList(Type).init(self.gpa);
854 defer types.deinit();
855
868856 var constituents = std.ArrayList(IdRef).init(self.gpa);
869857 defer constituents.deinit();
870858
......@@ -880,22 +868,23 @@ const DeclGen = struct {
880868 const field_val = try val.fieldValue(mod, field_index);
881869 const field_id = try self.constant(field_ty, field_val, .indirect);
882870
871 try types.append(field_ty);
883872 try constituents.append(field_id);
884873 }
885874
886 return try self.constructStruct(result_ty_ref, constituents.items);
875 return try self.constructStruct(ty, types.items, constituents.items);
887876 },
888877 .anon_struct_type => unreachable, // TODO
889878 else => unreachable,
890879 },
891880 .un => |un| {
892881 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;
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)
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)
896886 else
897887 null;
898
899888 return try self.unionInit(ty, active_field, payload);
900889 },
901890 .memoized_call => unreachable,
......@@ -934,8 +923,7 @@ const DeclGen = struct {
934923
935924 // TODO: Can we consolidate this in ptrElemPtr?
936925 const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
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)));
926 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
939927
940928 if (elem_ptr_ty_ref == result_ty_ref) {
941929 return elem_ptr_id;
......@@ -997,8 +985,7 @@ const DeclGen = struct {
997985 };
998986
999987 const decl_id = try self.resolveAnonDecl(decl_val, actual_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);
988 const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class);
1002989
1003990 const ptr_id = switch (final_storage_class) {
1004991 .Generic => blk: {
......@@ -1054,8 +1041,7 @@ const DeclGen = struct {
10541041
10551042 const final_storage_class = spvStorageClass(decl.@"addrspace");
10561043
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);
1044 const decl_ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);
10591045
10601046 const ptr_id = switch (final_storage_class) {
10611047 .Generic => blk: {
......@@ -1123,29 +1109,52 @@ const DeclGen = struct {
11231109 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());
11241110 }
11251111
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:
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:
11301143 /// struct {
11311144 /// tag: TagType,
1132 /// payload: ActivePayloadType,
1133 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
1145 /// payload: MostAlignedFieldType,
1146 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
11341147 /// padding: [padding_size]u8,
11351148 /// }
11361149 /// If the payload alignment is greater than that of the tag:
11371150 /// struct {
1138 /// payload: ActivePayloadType,
1139 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,
1151 /// payload: MostAlignedFieldType,
1152 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
11401153 /// tag: TagType,
11411154 /// padding: [padding_size]u8,
11421155 /// }
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.
11451156 /// If any of the fields' size is 0, it will be omitted.
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 {
1157 fn resolveUnionType(self: *DeclGen, ty: Type) !CacheRef {
11491158 const mod = self.module;
11501159 const ip = &mod.intern_pool;
11511160 const union_obj = mod.typeToUnion(ty).?;
......@@ -1154,17 +1163,13 @@ const DeclGen = struct {
11541163 return self.todo("packed union types", .{});
11551164 }
11561165
1157 const layout = self.unionLayout(ty, maybe_active_field);
1158
1159 if (layout.payload_size == 0) {
1166 const layout = self.unionLayout(ty);
1167 if (!layout.has_payload) {
11601168 // No payload, so represent this as just the tag type.
11611169 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);
11621170 }
11631171
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 }
1172 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
11681173
11691174 var member_types: [4]CacheRef = undefined;
11701175 var member_names: [4]CacheString = undefined;
......@@ -1177,10 +1182,10 @@ const DeclGen = struct {
11771182 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");
11781183 }
11791184
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)");
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)");
11841189 }
11851190
11861191 if (layout.payload_padding_size != 0) {
......@@ -1201,9 +1206,7 @@ const DeclGen = struct {
12011206 .member_names = member_names[0..layout.total_fields],
12021207 } });
12031208
1204 if (maybe_active_field == null) {
1205 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1206 }
1209 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
12071210 return ty_ref;
12081211 }
12091212
......@@ -1351,12 +1354,12 @@ const DeclGen = struct {
13511354 .Pointer => {
13521355 const ptr_info = ty.ptrInfo(mod);
13531356
1357 // Note: Don't cache this pointer type, it would mess up the recursive pointer functionality
1358 // in ptrType()!
1359
13541360 const storage_class = spvStorageClass(ptr_info.flags.address_space);
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 } });
1361 const ptr_ty_ref = try self.ptrType(ptr_info.child.toType(), storage_class);
1362
13601363 if (ptr_info.flags.size != .Slice) {
13611364 return ptr_ty_ref;
13621365 }
......@@ -1471,7 +1474,7 @@ const DeclGen = struct {
14711474 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
14721475 return ty_ref;
14731476 },
1474 .Union => return try self.resolveUnionType(ty, null),
1477 .Union => return try self.resolveUnionType(ty),
14751478 .ErrorSet => return try self.intType(.unsigned, 16),
14761479 .ErrorUnion => {
14771480 const payload_ty = ty.errorUnionPayload(mod);
......@@ -1585,14 +1588,16 @@ const DeclGen = struct {
15851588 }
15861589
15871590 const UnionLayout = struct {
1588 active_field: u32,
1589 active_field_ty: Type,
1590 payload_size: u32,
1591
1591 /// If false, this union is represented
1592 /// by only an integer of the tag type.
1593 has_payload: bool,
15921594 tag_size: u32,
15931595 tag_index: u32,
1594 active_field_size: u32,
1595 active_field_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,
15961601 payload_padding_size: u32,
15971602 payload_padding_index: u32,
15981603 padding_size: u32,
......@@ -1600,23 +1605,19 @@ const DeclGen = struct {
16001605 total_fields: u32,
16011606 };
16021607
1603 fn unionLayout(self: *DeclGen, ty: Type, maybe_active_field: ?usize) UnionLayout {
1608 fn unionLayout(self: *DeclGen, ty: Type) UnionLayout {
16041609 const mod = self.module;
16051610 const ip = &mod.intern_pool;
16061611 const layout = ty.unionGetLayout(self.module);
16071612 const union_obj = mod.typeToUnion(ty).?;
16081613
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
16121614 var union_layout = UnionLayout{
1613 .active_field = @intCast(active_field),
1614 .active_field_ty = active_field_ty,
1615 .payload_size = @intCast(layout.payload_size),
1615 .has_payload = layout.payload_size != 0,
16161616 .tag_size = @intCast(layout.tag_size),
16171617 .tag_index = undefined,
1618 .active_field_size = undefined,
1619 .active_field_index = undefined,
1618 .payload_ty = undefined,
1619 .payload_size = undefined,
1620 .payload_index = undefined,
16201621 .payload_padding_size = undefined,
16211622 .payload_padding_index = undefined,
16221623 .padding_size = @intCast(layout.padding),
......@@ -1624,11 +1625,16 @@ const DeclGen = struct {
16241625 .total_fields = undefined,
16251626 };
16261627
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);
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);
16321638
16331639 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);
16341640 var field_index: u32 = 0;
......@@ -1638,8 +1644,8 @@ const DeclGen = struct {
16381644 field_index += 1;
16391645 }
16401646
1641 if (union_layout.active_field_size != 0) {
1642 union_layout.active_field_index = field_index;
1647 if (union_layout.payload_size != 0) {
1648 union_layout.payload_index = field_index;
16431649 field_index += 1;
16441650 }
16451651
......@@ -1683,7 +1689,7 @@ const DeclGen = struct {
16831689 /// the name of an error in the text executor.
16841690 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {
16851691 const anyerror_ty_ref = try self.resolveType(Type.anyerror, .direct);
1686 const ptr_anyerror_ty_ref = try self.spv.ptrType(anyerror_ty_ref, .CrossWorkgroup);
1692 const ptr_anyerror_ty_ref = try self.ptrType(Type.anyerror, .CrossWorkgroup);
16871693 const void_ty_ref = try self.resolveType(Type.void, .direct);
16881694
16891695 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
......@@ -1718,6 +1724,7 @@ const DeclGen = struct {
17181724 .id_result = error_id,
17191725 .function = test_id,
17201726 });
1727 // Note: Convert to direct not required.
17211728 try section.emit(self.spv.gpa, .OpStore, .{
17221729 .pointer = p_error_id,
17231730 .object = error_id,
......@@ -1822,8 +1829,7 @@ const DeclGen = struct {
18221829 else => final_storage_class,
18231830 };
18241831
1825 const ty_ref = try self.resolveType(decl.ty, .indirect);
1826 const ptr_ty_ref = try self.spv.ptrType(ty_ref, actual_storage_class);
1832 const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class);
18271833
18281834 const begin = self.spv.beginGlobal();
18291835 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{
......@@ -1928,11 +1934,15 @@ const DeclGen = struct {
19281934 return try self.convertToDirect(result_ty, result_id);
19291935 }
19301936
1931 fn load(self: *DeclGen, value_ty: Type, ptr_id: IdRef, is_volatile: bool) !IdRef {
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 {
19321942 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
19331943 const result_id = self.spv.allocId();
19341944 const access = spec.MemoryAccess.Extended{
1935 .Volatile = is_volatile,
1945 .Volatile = options.is_volatile,
19361946 };
19371947 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
19381948 .id_result_type = self.typeId(indirect_value_ty_ref),
......@@ -1943,10 +1953,10 @@ const DeclGen = struct {
19431953 return try self.convertToDirect(value_ty, result_id);
19441954 }
19451955
1946 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, is_volatile: bool) !void {
1956 fn store(self: *DeclGen, value_ty: Type, ptr_id: IdRef, value_id: IdRef, options: MemoryOptions) !void {
19471957 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
19481958 const access = spec.MemoryAccess.Extended{
1949 .Volatile = is_volatile,
1959 .Volatile = options.is_volatile,
19501960 };
19511961 try self.func.body.emit(self.spv.gpa, .OpStore, .{
19521962 .pointer = ptr_id,
......@@ -2118,9 +2128,7 @@ const DeclGen = struct {
21182128 constituent.* = try self.convertToIndirect(child_ty, result_id);
21192129 }
21202130
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);
2131 return try self.constructArray(ty, constituents);
21242132 }
21252133
21262134 const result_id = self.spv.allocId();
......@@ -2181,7 +2189,7 @@ const DeclGen = struct {
21812189
21822190 const info = try self.arithmeticTypeInfo(result_ty);
21832191 // TODO: Use fmin for OpenCL
2184 const cmp_id = try self.cmp(op, result_ty, lhs_id, rhs_id);
2192 const cmp_id = try self.cmp(op, Type.bool, result_ty, lhs_id, rhs_id);
21852193 const selection_id = switch (info.class) {
21862194 .float => blk: {
21872195 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,
......@@ -2316,7 +2324,7 @@ const DeclGen = struct {
23162324 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);
23172325 }
23182326
2319 return self.constructArray(result_ty_ref, constituents);
2327 return self.constructArray(ty, constituents);
23202328 }
23212329
23222330 // Binary operations are generally applicable to both scalar and vector operations
......@@ -2472,11 +2480,11 @@ const DeclGen = struct {
24722480 // Construct the struct that Zig wants as result.
24732481 // The value should already be the correct type.
24742482 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);
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 });
2483 return try self.constructStruct(
2484 result_ty,
2485 &.{ operand_ty, ov_ty },
2486 &.{ value_id, ov_id },
2487 );
24802488 }
24812489
24822490 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2634,6 +2642,7 @@ const DeclGen = struct {
26342642 fn cmp(
26352643 self: *DeclGen,
26362644 op: std.math.CompareOperator,
2645 result_ty: Type,
26372646 ty: Type,
26382647 lhs_id: IdRef,
26392648 rhs_id: IdRef,
......@@ -2674,7 +2683,7 @@ const DeclGen = struct {
26742683 if (ty.optionalReprIsPayload(mod)) {
26752684 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));
26762685 assert(!payload_ty.isSlice(mod));
2677 return self.cmp(op, payload_ty, lhs_id, rhs_id);
2686 return self.cmp(op, Type.bool, payload_ty, lhs_id, rhs_id);
26782687 }
26792688
26802689 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
......@@ -2687,7 +2696,7 @@ const DeclGen = struct {
26872696 else
26882697 try self.convertToDirect(Type.bool, rhs_id);
26892698
2690 const valid_cmp_id = try self.cmp(op, Type.bool, lhs_valid_id, rhs_valid_id);
2699 const valid_cmp_id = try self.cmp(op, Type.bool, Type.bool, lhs_valid_id, rhs_valid_id);
26912700 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
26922701 return valid_cmp_id;
26932702 }
......@@ -2698,7 +2707,7 @@ const DeclGen = struct {
26982707 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);
26992708 const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);
27002709
2701 const pl_cmp_id = try self.cmp(op, payload_ty, lhs_pl_id, rhs_pl_id);
2710 const pl_cmp_id = try self.cmp(op, Type.bool, payload_ty, lhs_pl_id, rhs_pl_id);
27022711
27032712 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl
27042713 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl
......@@ -2720,7 +2729,6 @@ const DeclGen = struct {
27202729 .Vector => {
27212730 const child_ty = ty.childType(mod);
27222731 const vector_len = ty.vectorLen(mod);
2723 const bool_ty_ref_indirect = try self.resolveType(Type.bool, .indirect);
27242732
27252733 var constituents = try self.gpa.alloc(IdRef, vector_len);
27262734 defer self.gpa.free(constituents);
......@@ -2728,12 +2736,11 @@ const DeclGen = struct {
27282736 for (constituents, 0..) |*constituent, i| {
27292737 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));
27302738 const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));
2731 const result_id = try self.cmp(op, child_ty, lhs_index_id, rhs_index_id);
2739 const result_id = try self.cmp(op, Type.bool, child_ty, lhs_index_id, rhs_index_id);
27322740 constituent.* = try self.convertToIndirect(Type.bool, result_id);
27332741 }
27342742
2735 const result_ty_ref = try self.spv.arrayType(vector_len, bool_ty_ref_indirect);
2736 return try self.constructArray(result_ty_ref, constituents);
2743 return try self.constructArray(result_ty, constituents);
27372744 },
27382745 else => unreachable,
27392746 };
......@@ -2806,8 +2813,9 @@ const DeclGen = struct {
28062813 const lhs_id = try self.resolve(bin_op.lhs);
28072814 const rhs_id = try self.resolve(bin_op.rhs);
28082815 const ty = self.typeOf(bin_op.lhs);
2816 const result_ty = self.typeOfIndex(inst);
28092817
2810 return try self.cmp(op, ty, lhs_id, rhs_id);
2818 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
28112819 }
28122820
28132821 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -2819,8 +2827,9 @@ const DeclGen = struct {
28192827 const rhs_id = try self.resolve(vec_cmp.rhs);
28202828 const op = vec_cmp.compareOperator();
28212829 const ty = self.typeOf(vec_cmp.lhs);
2830 const result_ty = self.typeOfIndex(inst);
28222831
2823 return try self.cmp(op, ty, lhs_id, rhs_id);
2832 return try self.cmp(op, result_ty, ty, lhs_id, rhs_id);
28242833 }
28252834
28262835 fn bitCast(
......@@ -2865,23 +2874,17 @@ const DeclGen = struct {
28652874 return result_id;
28662875 }
28672876
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);
2877 const dst_ptr_ty_ref = try self.ptrType(dst_ty, .Function);
28702878
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);
2879 const tmp_id = try self.alloc(src_ty, .{ .storage_class = .Function });
2880 try self.store(src_ty, tmp_id, src_id, .{});
28782881 const casted_ptr_id = self.spv.allocId();
28792882 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
28802883 .id_result_type = self.typeId(dst_ptr_ty_ref),
28812884 .id_result = casted_ptr_id,
28822885 .operand = tmp_id,
28832886 });
2884 return try self.load(dst_ty, casted_ptr_id, false);
2887 return try self.load(dst_ty, casted_ptr_id, .{});
28852888 }
28862889
28872890 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3060,7 +3063,6 @@ const DeclGen = struct {
30603063 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
30613064
30623065 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);
3063 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
30643066 const size_ty_ref = try self.sizeType();
30653067
30663068 const array_ptr_id = try self.resolve(ty_op.operand);
......@@ -3073,7 +3075,11 @@ const DeclGen = struct {
30733075 // Convert the pointer-to-array to a pointer to the first element.
30743076 try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});
30753077
3076 return try self.constructStruct(slice_ty_ref, &.{ elem_ptr_id, len_id });
3078 return try self.constructStruct(
3079 slice_ty,
3080 &.{ elem_ptr_ty, Type.usize },
3081 &.{ elem_ptr_id, len_id },
3082 );
30773083 }
30783084
30793085 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3083,13 +3089,16 @@ const DeclGen = struct {
30833089 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
30843090 const ptr_id = try self.resolve(bin_op.lhs);
30853091 const len_id = try self.resolve(bin_op.rhs);
3092 const ptr_ty = self.typeOf(bin_op.lhs);
30863093 const slice_ty = self.typeOfIndex(inst);
3087 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
30883094
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 });
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 );
30933102 }
30943103
30953104 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3099,7 +3108,6 @@ const DeclGen = struct {
30993108 const ip = &mod.intern_pool;
31003109 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
31013110 const result_ty = self.typeOfIndex(inst);
3102 const result_ty_ref = try self.resolveType(result_ty, .direct);
31033111 const len: usize = @intCast(result_ty.arrayLen(mod));
31043112 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
31053113
......@@ -3111,6 +3119,8 @@ const DeclGen = struct {
31113119 unreachable; // TODO
31123120 }
31133121
3122 const types = try self.gpa.alloc(Type, elements.len);
3123 defer self.gpa.free(types);
31143124 const constituents = try self.gpa.alloc(IdRef, elements.len);
31153125 defer self.gpa.free(constituents);
31163126 var index: usize = 0;
......@@ -3122,6 +3132,7 @@ const DeclGen = struct {
31223132 assert(field_ty.toType().hasRuntimeBits(mod));
31233133
31243134 const id = try self.resolve(element);
3135 types[index] = field_ty.toType();
31253136 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);
31263137 index += 1;
31273138 }
......@@ -3135,6 +3146,7 @@ const DeclGen = struct {
31353146 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));
31363147
31373148 const id = try self.resolve(element);
3149 types[index] = field_ty;
31383150 constituents[index] = try self.convertToIndirect(field_ty, id);
31393151 index += 1;
31403152 }
......@@ -3142,7 +3154,11 @@ const DeclGen = struct {
31423154 else => unreachable,
31433155 }
31443156
3145 return try self.constructStruct(result_ty_ref, constituents[0..index]);
3157 return try self.constructStruct(
3158 result_ty,
3159 types[0..index],
3160 constituents[0..index],
3161 );
31463162 },
31473163 .Array => {
31483164 const array_info = result_ty.arrayInfo(mod);
......@@ -3159,7 +3175,7 @@ const DeclGen = struct {
31593175 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);
31603176 }
31613177
3162 return try self.constructArray(result_ty_ref, elem_ids);
3178 return try self.constructArray(result_ty, elem_ids);
31633179 },
31643180 else => unreachable,
31653181 }
......@@ -3244,15 +3260,14 @@ const DeclGen = struct {
32443260
32453261 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
32463262 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});
3247 return try self.load(slice_ty.childType(mod), elem_ptr, slice_ty.isVolatilePtr(mod));
3263 return try self.load(slice_ty.childType(mod), elem_ptr, .{ .is_volatile = slice_ty.isVolatilePtr(mod) });
32483264 }
32493265
32503266 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
32513267 const mod = self.module;
32523268 // Construct new pointer type for the resulting pointer
32533269 const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.
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)));
3270 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
32563271 if (ptr_ty.isSinglePointer(mod)) {
32573272 // Pointer-to-array. In this case, the resulting pointer is not of the same type
32583273 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.
......@@ -3288,9 +3303,7 @@ const DeclGen = struct {
32883303 const mod = self.module;
32893304 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
32903305 const array_ty = self.typeOf(bin_op.lhs);
3291 const array_ty_ref = try self.resolveType(array_ty, .direct);
32923306 const elem_ty = array_ty.childType(mod);
3293 const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
32943307 const array_id = try self.resolve(bin_op.lhs);
32953308 const index_id = try self.resolve(bin_op.rhs);
32963309
......@@ -3298,22 +3311,12 @@ const DeclGen = struct {
32983311 // For now, just generate a temporary and use that.
32993312 // TODO: This backend probably also should use isByRef from llvm...
33003313
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 });
3314 const elem_ptr_ty_ref = try self.ptrType(elem_ty, .Function);
33143315
3316 const tmp_id = try self.alloc(array_ty, .{ .storage_class = .Function });
3317 try self.store(array_ty, tmp_id, array_id, .{});
33153318 const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id});
3316 return try self.load(elem_ty, elem_ptr_id, false);
3319 return try self.load(elem_ty, elem_ptr_id, .{});
33173320 }
33183321
33193322 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3326,7 +3329,7 @@ const DeclGen = struct {
33263329 const ptr_id = try self.resolve(bin_op.lhs);
33273330 const index_id = try self.resolve(bin_op.rhs);
33283331 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);
3329 return try self.load(elem_ty, elem_ptr_id, ptr_ty.isVolatilePtr(mod));
3332 return try self.load(elem_ty, elem_ptr_id, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
33303333 }
33313334
33323335 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3334,22 +3337,21 @@ const DeclGen = struct {
33343337 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
33353338 const un_ptr_ty = self.typeOf(bin_op.lhs);
33363339 const un_ty = un_ptr_ty.childType(mod);
3337 const layout = self.unionLayout(un_ty, null);
3340 const layout = self.unionLayout(un_ty);
33383341
33393342 if (layout.tag_size == 0) return;
33403343
33413344 const tag_ty = un_ty.unionTagTypeSafety(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)));
3345 const tag_ptr_ty_ref = try self.ptrType(tag_ty, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
33443346
33453347 const union_ptr_id = try self.resolve(bin_op.lhs);
33463348 const new_tag_id = try self.resolve(bin_op.rhs);
33473349
3348 if (layout.payload_size == 0) {
3349 try self.store(tag_ty, union_ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));
3350 if (!layout.has_payload) {
3351 try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
33503352 } else {
33513353 const ptr_id = try self.accessChain(tag_ptr_ty_ref, union_ptr_id, &.{layout.tag_index});
3352 try self.store(tag_ty, ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));
3354 try self.store(tag_ty, ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
33533355 }
33543356 }
33553357
......@@ -3360,11 +3362,11 @@ const DeclGen = struct {
33603362 const un_ty = self.typeOf(ty_op.operand);
33613363
33623364 const mod = self.module;
3363 const layout = self.unionLayout(un_ty, null);
3365 const layout = self.unionLayout(un_ty);
33643366 if (layout.tag_size == 0) return null;
33653367
33663368 const union_handle = try self.resolve(ty_op.operand);
3367 if (layout.payload_size == 0) return union_handle;
3369 if (!layout.has_payload) return union_handle;
33683370
33693371 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
33703372 return try self.extractField(tag_ty, union_handle, layout.tag_index);
......@@ -3377,8 +3379,8 @@ const DeclGen = struct {
33773379 payload: ?IdRef,
33783380 ) !IdRef {
33793381 // To initialize a union, generate a temporary variable with the
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.
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.
33823384
33833385 const mod = self.module;
33843386 const ip = &mod.intern_pool;
......@@ -3389,7 +3391,7 @@ const DeclGen = struct {
33893391 }
33903392
33913393 const maybe_tag_ty = ty.unionTagTypeSafety(mod);
3392 const layout = self.unionLayout(ty, active_field);
3394 const layout = self.unionLayout(ty);
33933395
33943396 const tag_int = if (layout.tag_size != 0) blk: {
33953397 const tag_ty = maybe_tag_ty.?;
......@@ -3400,42 +3402,34 @@ const DeclGen = struct {
34003402 break :blk tag_int_val.toUnsignedInt(mod);
34013403 } else 0;
34023404
3403 if (layout.payload_size == 0) {
3405 if (!layout.has_payload) {
34043406 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
34053407 return try self.constInt(tag_ty_ref, tag_int);
34063408 }
34073409
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 });
3410 const tmp_id = try self.alloc(ty, .{ .storage_class = .Function });
34193411
34203412 if (layout.tag_size != 0) {
34213413 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
3422 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, .Function);
3414 const tag_ptr_ty_ref = try self.ptrType(maybe_tag_ty.?, .Function);
34233415 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});
34243416 const tag_id = try self.constInt(tag_ty_ref, tag_int);
3425 try self.func.body.emit(self.spv.gpa, .OpStore, .{
3426 .pointer = ptr_id,
3427 .object = tag_id,
3428 });
3417 try self.store(maybe_tag_ty.?, ptr_id, tag_id, .{});
34293418 }
34303419
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.?,
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,
34383430 });
3431
3432 try self.store(payload_ty, active_pl_ptr_id, payload.?, .{});
34393433 } else {
34403434 assert(payload == null);
34413435 }
......@@ -3443,34 +3437,21 @@ const DeclGen = struct {
34433437 // Just leave the padding fields uninitialized...
34443438 // TODO: Or should we initialize them with undef explicitly?
34453439
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;
3440 return try self.load(ty, tmp_id, .{});
34633441 }
34643442
34653443 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
34663444 if (self.liveness.isUnused(inst)) return null;
34673445
3446 const mod = self.module;
3447 const ip = &mod.intern_pool;
34683448 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
34693449 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
34703450 const ty = self.typeOfIndex(inst);
3471 const layout = self.unionLayout(ty, extra.field_index);
34723451
3473 const payload = if (layout.active_field_size != 0)
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))
34743455 try self.resolve(extra.init)
34753456 else
34763457 null;
......@@ -3499,30 +3480,24 @@ const DeclGen = struct {
34993480 .Union => switch (object_ty.containerLayout(mod)) {
35003481 .Packed => unreachable, // TODO
35013482 else => {
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();
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();
35183495 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3519 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3520 .id_result = casted_tmp_id,
3521 .operand = tmp_id,
3496 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3497 .id_result = active_pl_ptr_id,
3498 .operand = pl_ptr_id,
35223499 });
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);
3500 return try self.load(field_ty, active_pl_ptr_id, .{});
35263501 },
35273502 },
35283503 else => unreachable,
......@@ -3581,18 +3556,24 @@ const DeclGen = struct {
35813556 .Union => switch (object_ty.containerLayout(mod)) {
35823557 .Packed => unreachable, // TODO
35833558 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
35843566 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));
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);
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});
35873569
3588 const casted_id = self.spv.allocId();
3570 const active_pl_ptr_id = self.spv.allocId();
35893571 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3590 .id_result_type = self.typeId(un_active_ptr_ty_ref),
3591 .id_result = casted_id,
3592 .operand = object_ptr,
3572 .id_result_type = self.typeId(result_ty_ref),
3573 .id_result = active_pl_ptr_id,
3574 .operand = pl_ptr_id,
35933575 });
3594 const layout = self.unionLayout(object_ty, field_index);
3595 return try self.accessChain(result_ty_ref, casted_id, &.{layout.active_field_index});
3576 return active_pl_ptr_id;
35963577 },
35973578 },
35983579 else => unreachable,
......@@ -3608,23 +3589,13 @@ const DeclGen = struct {
36083589 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);
36093590 }
36103591
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 }
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 };
36283599
36293600 // Allocate a function-local variable, with possible initializer.
36303601 // This function returns a pointer to a variable of type `ty_ref`,
......@@ -3632,30 +3603,36 @@ const DeclGen = struct {
36323603 // placed in the Function address space.
36333604 fn alloc(
36343605 self: *DeclGen,
3635 ty_ref: CacheRef,
3636 initializer: ?IdRef,
3606 ty: Type,
3607 options: AllocOptions,
36373608 ) !IdRef {
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);
3609 const ptr_fn_ty_ref = try self.ptrType(ty, .Function);
36403610
36413611 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
36423612 // directly generate them into func.prologue instead of the body.
36433613 const var_id = self.spv.allocId();
36443614 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
3645 .id_result_type = self.typeId(fn_ptr_ty_ref),
3615 .id_result_type = self.typeId(ptr_fn_ty_ref),
36463616 .id_result = var_id,
36473617 .storage_class = .Function,
3648 .initializer = initializer,
3618 .initializer = options.initializer,
36493619 });
36503620
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;
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 }
36593636 }
36603637
36613638 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -3664,8 +3641,7 @@ const DeclGen = struct {
36643641 const ptr_ty = self.typeOfIndex(inst);
36653642 assert(ptr_ty.ptrAddressSpace(mod) == .generic);
36663643 const child_ty = ptr_ty.childType(mod);
3667 const child_ty_ref = try self.resolveType(child_ty, .indirect);
3668 return try self.alloc(child_ty_ref, null);
3644 return try self.alloc(child_ty, .{});
36693645 }
36703646
36713647 fn airArg(self: *DeclGen) IdRef {
......@@ -3780,7 +3756,7 @@ const DeclGen = struct {
37803756 const operand = try self.resolve(ty_op.operand);
37813757 if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;
37823758
3783 return try self.load(elem_ty, operand, ptr_ty.isVolatilePtr(mod));
3759 return try self.load(elem_ty, operand, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
37843760 }
37853761
37863762 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3790,7 +3766,7 @@ const DeclGen = struct {
37903766 const ptr = try self.resolve(bin_op.lhs);
37913767 const value = try self.resolve(bin_op.rhs);
37923768
3793 try self.store(elem_ty, ptr, value, ptr_ty.isVolatilePtr(self.module));
3769 try self.store(elem_ty, ptr, value, .{ .is_volatile = ptr_ty.isVolatilePtr(self.module) });
37943770 }
37953771
37963772 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -3854,7 +3830,7 @@ const DeclGen = struct {
38543830 }
38553831
38563832 const ptr = try self.resolve(un_op);
3857 const value = try self.load(ret_ty, ptr, ptr_ty.isVolatilePtr(mod));
3833 const value = try self.load(ret_ty, ptr, .{ .is_volatile = ptr_ty.isVolatilePtr(mod) });
38583834 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{
38593835 .value = value,
38603836 });
......@@ -3980,8 +3956,11 @@ const DeclGen = struct {
39803956 members[eu_layout.errorFieldIndex()] = operand_id;
39813957 members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref);
39823958
3983 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
3984 return try self.constructStruct(err_union_ty_ref, &members);
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);
39853964 }
39863965
39873966 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
......@@ -4002,8 +3981,11 @@ const DeclGen = struct {
40023981 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);
40033982 members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id);
40043983
4005 const err_union_ty_ref = try self.resolveType(err_union_ty, .direct);
4006 return try self.constructStruct(err_union_ty_ref, &members);
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);
40073989 }
40083990
40093991 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
......@@ -4037,7 +4019,7 @@ const DeclGen = struct {
40374019 .is_null => .eq,
40384020 .is_non_null => .neq,
40394021 };
4040 return try self.cmp(op, ptr_ty, ptr_id, null_id);
4022 return try self.cmp(op, Type.bool, ptr_ty, ptr_id, null_id);
40414023 }
40424024
40434025 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
......@@ -4135,10 +4117,10 @@ const DeclGen = struct {
41354117 return operand_id;
41364118 }
41374119
4138 const optional_ty_ref = try self.resolveType(optional_ty, .direct);
41394120 const payload_id = try self.convertToIndirect(payload_ty, operand_id);
41404121 const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };
4141 return try self.constructStruct(optional_ty_ref, &members);
4122 const types = [_]Type{ payload_ty, Type.bool };
4123 return try self.constructStruct(optional_ty, &types, &members);
41424124 }
41434125
41444126 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
......@@ -4420,6 +4402,7 @@ const DeclGen = struct {
44204402 }
44214403
44224404 // TODO: Multiple results
4405 // TODO: Check that the output type from assembly is the same as the type actually expected by Zig.
44234406 }
44244407
44254408 return null;
src/codegen/spirv/Assembler.zig+10-4
......@@ -304,10 +304,16 @@ 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 => try self.spv.ptrType(
308 try self.resolveTypeRef(operands[2].ref_id),
309 @as(spec.StorageClass, @enumFromInt(operands[1].value)),
310 ),
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 },
311317 .OpTypeFunction => blk: {
312318 const param_operands = operands[2..];
313319 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);
src/codegen/spirv/Cache.zig+182-124
......@@ -22,6 +22,8 @@ const Opcode = spec.Opcode;
2222const IdResult = spec.IdResult;
2323const StorageClass = spec.StorageClass;
2424
25const InternPool = @import("../../InternPool.zig");
26
2527const Self = @This();
2628
2729map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
......@@ -31,6 +33,8 @@ extra: std.ArrayListUnmanaged(u32) = .{},
3133string_bytes: std.ArrayListUnmanaged(u8) = .{},
3234strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},
3335
36recursive_ptrs: std.AutoHashMapUnmanaged(Ref, void) = .{},
37
3438const Item = struct {
3539 tag: Tag,
3640 /// The result-id that this item uses.
......@@ -62,18 +66,21 @@ const Tag = enum {
6266 /// Function (proto)type
6367 /// data is payload to FunctionType
6468 type_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,
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,
7478 /// Simple pointer type that does not have any decorations.
7579 /// data is payload to SimplePointerType
7680 type_ptr_simple,
81 /// A forward declaration for a pointer.
82 /// data is ForwardPointerType
83 type_fwd_ptr,
7784 /// Simple structure type that does not have any decorations.
7885 /// data is payload to SimpleStructType
7986 type_struct_simple,
......@@ -142,6 +149,12 @@ const Tag = enum {
142149 const SimplePointerType = struct {
143150 storage_class: StorageClass,
144151 child_type: Ref,
152 fwd: Ref,
153 };
154
155 const ForwardPointerType = struct {
156 storage_class: StorageClass,
157 zig_child_type: InternPool.Index,
145158 };
146159
147160 /// Trailing:
......@@ -163,14 +176,14 @@ const Tag = enum {
163176 fn encode(value: f64) Float64 {
164177 const bits = @as(u64, @bitCast(value));
165178 return .{
166 .low = @as(u32, @truncate(bits)),
167 .high = @as(u32, @truncate(bits >> 32)),
179 .low = @truncate(bits),
180 .high = @truncate(bits >> 32),
168181 };
169182 }
170183
171184 fn decode(self: Float64) f64 {
172185 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);
173 return @as(f64, @bitCast(bits));
186 return @bitCast(bits);
174187 }
175188 };
176189
......@@ -192,8 +205,8 @@ const Tag = enum {
192205 fn encode(ty: Ref, value: u64) Int64 {
193206 return .{
194207 .ty = ty,
195 .low = @as(u32, @truncate(value)),
196 .high = @as(u32, @truncate(value >> 32)),
208 .low = @truncate(value),
209 .high = @truncate(value >> 32),
197210 };
198211 }
199212
......@@ -210,8 +223,8 @@ const Tag = enum {
210223 fn encode(ty: Ref, value: i64) Int64 {
211224 return .{
212225 .ty = ty,
213 .low = @as(u32, @truncate(@as(u64, @bitCast(value)))),
214 .high = @as(u32, @truncate(@as(u64, @bitCast(value)) >> 32)),
226 .low = @truncate(@as(u64, @bitCast(value))),
227 .high = @truncate(@as(u64, @bitCast(value)) >> 32),
215228 };
216229 }
217230
......@@ -237,6 +250,7 @@ pub const Key = union(enum) {
237250 array_type: ArrayType,
238251 function_type: FunctionType,
239252 ptr_type: PointerType,
253 fwd_ptr_type: ForwardPointerType,
240254 struct_type: StructType,
241255 opaque_type: OpaqueType,
242256
......@@ -273,12 +287,18 @@ pub const Key = union(enum) {
273287 pub const PointerType = struct {
274288 storage_class: StorageClass,
275289 child_type: Ref,
290 fwd: Ref,
276291 // TODO: Decorations:
277292 // - Alignment
278293 // - ArrayStride,
279294 // - MaxByteOffset,
280295 };
281296
297 pub const ForwardPointerType = struct {
298 zig_child_type: InternPool.Index,
299 storage_class: StorageClass,
300 };
301
282302 pub const StructType = struct {
283303 // TODO: Decorations.
284304 /// The name of the structure. Can be `.none`.
......@@ -313,21 +333,21 @@ pub const Key = union(enum) {
313333 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.
314334 fn toBits32(self: Int) u32 {
315335 return switch (self.value) {
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)),
336 .uint64 => |val| @intCast(val),
337 .int64 => |val| if (val < 0) @bitCast(@as(i32, @intCast(val))) else @intCast(val),
318338 };
319339 }
320340
321341 fn toBits64(self: Int) u64 {
322342 return switch (self.value) {
323343 .uint64 => |val| val,
324 .int64 => |val| @as(u64, @bitCast(val)),
344 .int64 => |val| @bitCast(val),
325345 };
326346 }
327347
328348 fn to(self: Int, comptime T: type) T {
329349 return switch (self.value) {
330 inline else => |val| @as(T, @intCast(val)),
350 inline else => |val| @intCast(val),
331351 };
332352 }
333353 };
......@@ -387,7 +407,7 @@ pub const Key = union(enum) {
387407 },
388408 inline else => |key| std.hash.autoHash(&hasher, key),
389409 }
390 return @as(u32, @truncate(hasher.final()));
410 return @truncate(hasher.final());
391411 }
392412
393413 fn eql(a: Key, b: Key) bool {
......@@ -419,7 +439,7 @@ pub const Key = union(enum) {
419439
420440 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {
421441 _ = b_void;
422 return ctx.self.lookup(@as(Ref, @enumFromInt(b_index))).eql(a);
442 return ctx.self.lookup(@enumFromInt(b_index)).eql(a);
423443 }
424444
425445 pub fn hash(ctx: @This(), a: Key) u32 {
......@@ -450,6 +470,7 @@ pub fn deinit(self: *Self, spv: *const Module) void {
450470 self.extra.deinit(spv.gpa);
451471 self.string_bytes.deinit(spv.gpa);
452472 self.strings.deinit(spv.gpa);
473 self.recursive_ptrs.deinit(spv.gpa);
453474}
454475
455476/// Actually materialize the database into spir-v instructions.
......@@ -460,7 +481,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {
460481 var section = Section{};
461482 errdefer section.deinit(spv.gpa);
462483 for (self.items.items(.result_id), 0..) |result_id, index| {
463 try self.emit(spv, result_id, @as(Ref, @enumFromInt(index)), &section);
484 try self.emit(spv, result_id, @enumFromInt(index), &section);
464485 }
465486 return section;
466487}
......@@ -538,6 +559,15 @@ fn emit(
538559 });
539560 // TODO: Decorations?
540561 },
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 },
541571 .struct_type => |struct_type| {
542572 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);
543573 section.writeOperand(IdResult, result_id);
......@@ -549,7 +579,7 @@ fn emit(
549579 }
550580 for (struct_type.memberNames(), 0..) |member_name, i| {
551581 if (self.getString(member_name)) |name| {
552 try spv.memberDebugName(result_id, @as(u32, @intCast(i)), name);
582 try spv.memberDebugName(result_id, @intCast(i), name);
553583 }
554584 }
555585 // TODO: Decorations?
......@@ -625,13 +655,12 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
625655 const adapter: Key.Adapter = .{ .self = self };
626656 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);
627657 if (entry.found_existing) {
628 return @as(Ref, @enumFromInt(entry.index));
658 return @enumFromInt(entry.index);
629659 }
630 const result_id = spv.allocId();
631660 const item: Item = switch (key) {
632661 inline .void_type, .bool_type => .{
633662 .tag = .type_simple,
634 .result_id = result_id,
663 .result_id = spv.allocId(),
635664 .data = @intFromEnum(key.toSimpleType()),
636665 },
637666 .int_type => |int| blk: {
......@@ -641,87 +670,104 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
641670 };
642671 break :blk .{
643672 .tag = t,
644 .result_id = result_id,
673 .result_id = spv.allocId(),
645674 .data = int.bits,
646675 };
647676 },
648677 .float_type => |float| .{
649678 .tag = .type_float,
650 .result_id = result_id,
679 .result_id = spv.allocId(),
651680 .data = float.bits,
652681 },
653682 .vector_type => |vector| .{
654683 .tag = .type_vector,
655 .result_id = result_id,
684 .result_id = spv.allocId(),
656685 .data = try self.addExtra(spv, vector),
657686 },
658687 .array_type => |array| .{
659688 .tag = .type_array,
660 .result_id = result_id,
689 .result_id = spv.allocId(),
661690 .data = try self.addExtra(spv, array),
662691 },
663692 .function_type => |function| blk: {
664693 const extra = try self.addExtra(spv, Tag.FunctionType{
665 .param_len = @as(u32, @intCast(function.parameters.len)),
694 .param_len = @intCast(function.parameters.len),
666695 .return_type = function.return_type,
667696 });
668 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(function.parameters)));
697 try self.extra.appendSlice(spv.gpa, @ptrCast(function.parameters));
669698 break :blk .{
670699 .tag = .type_function,
671 .result_id = result_id,
700 .result_id = spv.allocId(),
672701 .data = extra,
673702 };
674703 },
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 },
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 }),
699745 },
700746 .struct_type => |struct_type| blk: {
701747 const extra = try self.addExtra(spv, Tag.SimpleStructType{
702748 .name = struct_type.name,
703 .members_len = @as(u32, @intCast(struct_type.member_types.len)),
749 .members_len = @intCast(struct_type.member_types.len),
704750 });
705 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(struct_type.member_types)));
751 try self.extra.appendSlice(spv.gpa, @ptrCast(struct_type.member_types));
706752
707753 if (struct_type.member_names) |member_names| {
708 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(member_names)));
754 try self.extra.appendSlice(spv.gpa, @ptrCast(member_names));
709755 break :blk Item{
710756 .tag = .type_struct_simple_with_member_names,
711 .result_id = result_id,
757 .result_id = spv.allocId(),
712758 .data = extra,
713759 };
714760 } else {
715761 break :blk Item{
716762 .tag = .type_struct_simple,
717 .result_id = result_id,
763 .result_id = spv.allocId(),
718764 .data = extra,
719765 };
720766 }
721767 },
722768 .opaque_type => |opaque_type| Item{
723769 .tag = .type_opaque,
724 .result_id = result_id,
770 .result_id = spv.allocId(),
725771 .data = @intFromEnum(opaque_type.name),
726772 },
727773 .int => |int| blk: {
......@@ -729,13 +775,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
729775 if (int_type.signedness == .unsigned and int_type.bits == 8) {
730776 break :blk .{
731777 .tag = .uint8,
732 .result_id = result_id,
778 .result_id = spv.allocId(),
733779 .data = int.to(u8),
734780 };
735781 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {
736782 break :blk .{
737783 .tag = .uint32,
738 .result_id = result_id,
784 .result_id = spv.allocId(),
739785 .data = int.to(u32),
740786 };
741787 }
......@@ -745,32 +791,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
745791 if (val >= 0 and val <= std.math.maxInt(u32)) {
746792 break :blk .{
747793 .tag = .uint_small,
748 .result_id = result_id,
794 .result_id = spv.allocId(),
749795 .data = try self.addExtra(spv, Tag.UInt32{
750796 .ty = int.ty,
751 .value = @as(u32, @intCast(val)),
797 .value = @intCast(val),
752798 }),
753799 };
754800 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {
755801 break :blk .{
756802 .tag = .int_small,
757 .result_id = result_id,
803 .result_id = spv.allocId(),
758804 .data = try self.addExtra(spv, Tag.Int32{
759805 .ty = int.ty,
760 .value = @as(i32, @intCast(val)),
806 .value = @intCast(val),
761807 }),
762808 };
763809 } else if (val < 0) {
764810 break :blk .{
765811 .tag = .int_large,
766 .result_id = result_id,
767 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @as(i64, @intCast(val)))),
812 .result_id = spv.allocId(),
813 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @intCast(val))),
768814 };
769815 } else {
770816 break :blk .{
771817 .tag = .uint_large,
772 .result_id = result_id,
773 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @as(u64, @intCast(val)))),
818 .result_id = spv.allocId(),
819 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @intCast(val))),
774820 };
775821 }
776822 },
......@@ -779,29 +825,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
779825 .float => |float| switch (self.lookup(float.ty).float_type.bits) {
780826 16 => .{
781827 .tag = .float16,
782 .result_id = result_id,
828 .result_id = spv.allocId(),
783829 .data = @as(u16, @bitCast(float.value.float16)),
784830 },
785831 32 => .{
786832 .tag = .float32,
787 .result_id = result_id,
833 .result_id = spv.allocId(),
788834 .data = @as(u32, @bitCast(float.value.float32)),
789835 },
790836 64 => .{
791837 .tag = .float64,
792 .result_id = result_id,
838 .result_id = spv.allocId(),
793839 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),
794840 },
795841 else => unreachable,
796842 },
797843 .undef => |undef| .{
798844 .tag = .undef,
799 .result_id = result_id,
845 .result_id = spv.allocId(),
800846 .data = @intFromEnum(undef.ty),
801847 },
802848 .null => |null_info| .{
803849 .tag = .null,
804 .result_id = result_id,
850 .result_id = spv.allocId(),
805851 .data = @intFromEnum(null_info.ty),
806852 },
807853 .bool => |bool_info| .{
......@@ -809,13 +855,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
809855 true => Tag.bool_true,
810856 false => Tag.bool_false,
811857 },
812 .result_id = result_id,
858 .result_id = spv.allocId(),
813859 .data = @intFromEnum(bool_info.ty),
814860 },
815861 };
816862 try self.items.append(spv.gpa, item);
817863
818 return @as(Ref, @enumFromInt(entry.index));
864 return @enumFromInt(entry.index);
819865}
820866
821867/// Turn a Ref back into a Key.
......@@ -830,14 +876,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
830876 },
831877 .type_int_signed => .{ .int_type = .{
832878 .signedness = .signed,
833 .bits = @as(u16, @intCast(data)),
879 .bits = @intCast(data),
834880 } },
835881 .type_int_unsigned => .{ .int_type = .{
836882 .signedness = .unsigned,
837 .bits = @as(u16, @intCast(data)),
883 .bits = @intCast(data),
838884 } },
839885 .type_float => .{ .float_type = .{
840 .bits = @as(u16, @intCast(data)),
886 .bits = @intCast(data),
841887 } },
842888 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },
843889 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },
......@@ -846,40 +892,50 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
846892 return .{
847893 .function_type = .{
848894 .return_type = payload.data.return_type,
849 .parameters = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len])),
895 .parameters = @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len]),
850896 },
851897 };
852898 },
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 },
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 // },
871917 .type_ptr_simple => {
872918 const payload = self.extraData(Tag.SimplePointerType, data);
873919 return .{
874920 .ptr_type = .{
875921 .storage_class = payload.storage_class,
876922 .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,
877933 },
878934 };
879935 },
880936 .type_struct_simple => {
881937 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
882 const member_types = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]));
938 const member_types: []const Ref = @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]);
883939 return .{
884940 .struct_type = .{
885941 .name = payload.data.name,
......@@ -891,8 +947,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
891947 .type_struct_simple_with_member_names => {
892948 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
893949 const trailing = self.extra.items[payload.trail..];
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]));
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]);
896952 return .{
897953 .struct_type = .{
898954 .name = payload.data.name,
......@@ -903,16 +959,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
903959 },
904960 .type_opaque => .{
905961 .opaque_type = .{
906 .name = @as(String, @enumFromInt(data)),
962 .name = @enumFromInt(data),
907963 },
908964 },
909965 .float16 => .{ .float = .{
910966 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),
911 .value = .{ .float16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },
967 .value = .{ .float16 = @bitCast(@as(u16, @intCast(data))) },
912968 } },
913969 .float32 => .{ .float = .{
914970 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),
915 .value = .{ .float32 = @as(f32, @bitCast(data)) },
971 .value = .{ .float32 = @bitCast(data) },
916972 } },
917973 .float64 => .{ .float = .{
918974 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),
......@@ -955,17 +1011,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
9551011 } };
9561012 },
9571013 .undef => .{ .undef = .{
958 .ty = @as(Ref, @enumFromInt(data)),
1014 .ty = @enumFromInt(data),
9591015 } },
9601016 .null => .{ .null = .{
961 .ty = @as(Ref, @enumFromInt(data)),
1017 .ty = @enumFromInt(data),
9621018 } },
9631019 .bool_true => .{ .bool = .{
964 .ty = @as(Ref, @enumFromInt(data)),
1020 .ty = @enumFromInt(data),
9651021 .value = true,
9661022 } },
9671023 .bool_false => .{ .bool = .{
968 .ty = @as(Ref, @enumFromInt(data)),
1024 .ty = @enumFromInt(data),
9691025 .value = false,
9701026 } },
9711027 };
......@@ -981,7 +1037,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {
9811037fn get(self: *const Self, key: Key) Ref {
9821038 const adapter: Key.Adapter = .{ .self = self };
9831039 const index = self.map.getIndexAdapted(key, adapter).?;
984 return @as(Ref, @enumFromInt(index));
1040 return @enumFromInt(index);
9851041}
9861042
9871043fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
......@@ -991,15 +1047,16 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
9911047}
9921048
9931049fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {
994 const payload_offset = @as(u32, @intCast(self.extra.items.len));
1050 const payload_offset: u32 = @intCast(self.extra.items.len);
9951051 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
9961052 const field_val = @field(extra, field.name);
997 const word = switch (field.type) {
1053 const word: u32 = switch (field.type) {
9981054 u32 => field_val,
999 i32 => @as(u32, @bitCast(field_val)),
1055 i32 => @bitCast(field_val),
10001056 Ref => @intFromEnum(field_val),
10011057 StorageClass => @intFromEnum(field_val),
10021058 String => @intFromEnum(field_val),
1059 InternPool.Index => @intFromEnum(field_val),
10031060 else => @compileError("Invalid type: " ++ @typeName(field.type)),
10041061 };
10051062 self.extra.appendAssumeCapacity(word);
......@@ -1018,10 +1075,11 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t
10181075 const word = self.extra.items[offset + i];
10191076 @field(result, field.name) = switch (field.type) {
10201077 u32 => 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)),
1078 i32 => @bitCast(word),
1079 Ref => @enumFromInt(word),
1080 StorageClass => @enumFromInt(word),
1081 String => @enumFromInt(word),
1082 InternPool.Index => @enumFromInt(word),
10251083 else => @compileError("Invalid type: " ++ @typeName(field.type)),
10261084 };
10271085 }
......@@ -1049,7 +1107,7 @@ pub const String = enum(u32) {
10491107 _ = ctx;
10501108 var hasher = std.hash.Wyhash.init(0);
10511109 hasher.update(a);
1052 return @as(u32, @truncate(hasher.final()));
1110 return @truncate(hasher.final());
10531111 }
10541112 };
10551113};
......@@ -1064,10 +1122,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {
10641122 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);
10651123 self.string_bytes.appendSliceAssumeCapacity(str);
10661124 self.string_bytes.appendAssumeCapacity(0);
1067 entry.value_ptr.* = @as(u32, @intCast(offset));
1125 entry.value_ptr.* = @intCast(offset);
10681126 }
10691127
1070 return @as(String, @enumFromInt(entry.index));
1128 return @enumFromInt(entry.index);
10711129}
10721130
10731131pub fn getString(self: *const Self, ref: String) ?[]const u8 {
src/codegen/spirv/Module.zig-11
......@@ -507,17 +507,6 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {
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
521510pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {
522511 const ty = self.cache.lookup(ty_ref).int_type;
523512 const Value = Cache.Key.Int.Value;
test/behavior/bugs/12000.zig-1
......@@ -9,7 +9,6 @@ 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;
1312
1413 var t: T = .{ .next = null };
1514 try std.testing.expect(t.next == null);
test/behavior/bugs/1735.zig-1
......@@ -44,7 +44,6 @@ 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;
4847
4948 var t = a.init();
5049 try std.testing.expect(t.foo.len == 0);
test/behavior/bugs/1914.zig-4
......@@ -12,8 +12,6 @@ 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
1715 const assert = std.debug.assert;
1816 const obj = B{ .a_pointer = &a };
1917 assert(obj.a_pointer == &a); // this makes zig crash
......@@ -30,7 +28,5 @@ pub const B2 = struct {
3028var b_value = B2{ .pointer_array = &[_]*A2{} };
3129
3230test "basic stuff" {
33 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34
3531 std.debug.assert(&b_value == &b_value);
3632}
test/behavior/bugs/2006.zig-1
......@@ -7,7 +7,6 @@ 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;
1110
1211 var a: S = undefined;
1312 a = S{ .p = undefined };
test/behavior/bugs/3007.zig-1
......@@ -22,7 +22,6 @@ 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;
2625
2726 default_foo = get_foo() catch null; // This Line
2827 try std.testing.expect(!default_foo.?.free);
test/behavior/bugs/6947.zig-1
......@@ -8,7 +8,6 @@ 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;
1211
1312 var slice: []void = undefined;
1413 destroy(&slice[0]);
test/behavior/bugs/7325.zig-1
......@@ -81,7 +81,6 @@ 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;
8584
8685 var param: ParamType = .{
8786 .one_of = .{ .name = "name" },
test/behavior/error.zig-1
......@@ -943,7 +943,6 @@ test "returning an error union containing a type with no runtime bits" {
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;
947946
948947 const Value = union(enum) {
949948 values: []const @This(),
test/behavior/eval.zig-4
......@@ -391,7 +391,6 @@ 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;
395394
396395 st_init_str_foo.x += 1;
397396 try expect(st_init_str_foo.x == 14);
......@@ -498,7 +497,6 @@ test "comptime shlWithOverflow" {
498497test "const ptr to variable data changes at runtime" {
499498 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500499 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
502500
503501 try expect(foo_ref.name[0] == 'a');
504502 foo_ref.name = "b";
......@@ -1551,8 +1549,6 @@ test "comptime function turns function value to function pointer" {
15511549}
15521550
15531551test "container level const and var have unique addresses" {
1554 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1555
15561552 const S = struct {
15571553 x: i32,
15581554 y: i32,
test/behavior/generics.zig-1
......@@ -205,7 +205,6 @@ 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;
209208
210209 var a1 = GenNode(i32){
211210 .value = 13,
test/behavior/null.zig-1
......@@ -185,7 +185,6 @@ 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;
189188
190189 struct_with_optional.field = null;
191190 if (struct_with_optional.field) |payload| {
test/behavior/optional.zig-1
......@@ -193,7 +193,6 @@ 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;
197196
198197 const S = struct {
199198 const Node = struct {
test/behavior/ptrcast.zig-2
......@@ -130,7 +130,6 @@ 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;
134133
135134 // Test lowering a field ptr
136135 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
......@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr" {
153152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
155154 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157155
158156 // Test lowering a field ptr
159157 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
test/behavior/struct.zig-6
......@@ -292,7 +292,6 @@ const Val = struct {
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;
296295
297296 var root: Node = undefined;
298297 root.val.x = 1;
......@@ -347,7 +346,6 @@ test "self-referencing struct via array member" {
347346 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
348347 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349348 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
351349
352350 const T = struct {
353351 children: [1]*@This(),
......@@ -370,7 +368,6 @@ const EmptyStruct = struct {
370368
371369test "align 1 field before self referential align 8 field as slice return type" {
372370 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
374371
375372 const result = alloc(Expr);
376373 try expect(result.len == 0);
......@@ -736,7 +733,6 @@ test "packed struct with u0 field access" {
736733test "access to global struct fields" {
737734 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
738735 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
740736
741737 g_foo.bar.value = 42;
742738 try expect(g_foo.bar.value == 42);
......@@ -1423,7 +1419,6 @@ test "fieldParentPtr of a zero-bit field" {
14231419
14241420test "struct field has a pointer to an aligned version of itself" {
14251421 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1426 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14271422
14281423 const E = struct {
14291424 next: *align(1) @This(),
......@@ -1519,7 +1514,6 @@ test "function pointer in struct returns the struct" {
15191514
15201515test "no dependency loop on optional field wrapped in generic function" {
15211516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1522 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15231517
15241518 const S = struct {
15251519 fn Atomic(comptime T: type) type {
test/behavior/struct_contains_null_ptr_itself.zig-1
......@@ -5,7 +5,6 @@ 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;
98
109 var x: ?*NodeLineComment = null;
1110 try expect(x == null);
test/behavior/struct_contains_slice_of_itself.zig-2
......@@ -13,7 +13,6 @@ 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;
1716
1817 var other_nodes = [_]Node{
1918 Node{
......@@ -54,7 +53,6 @@ test "struct contains slice of itself" {
5453test "struct contains aligned slice of itself" {
5554 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5655 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5856
5957 var other_nodes = [_]NodeAligned{
6058 NodeAligned{
test/behavior/union.zig-10
......@@ -399,7 +399,6 @@ 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;
403402
404403 const a = UnionEnumNoPayloads{ .B = {} };
405404 switch (a) {
......@@ -474,7 +473,6 @@ test "update the tag value for zero-sized unions" {
474473 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
475474 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
476475 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
478476
479477 const S = union(enum) {
480478 U0: void,
......@@ -515,7 +513,6 @@ test "method call on an empty union" {
515513 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
516514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
517515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
519516
520517 const S = struct {
521518 const MyUnion = union(MyUnionTag) {
......@@ -593,7 +590,6 @@ test "tagged union with all void fields but a meaningful tag" {
593590 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
594591 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595592 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
597593
598594 const S = struct {
599595 const B = union(enum) {
......@@ -795,7 +791,6 @@ test "@unionInit stored to a const" {
795791 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
796792 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
797793 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
798 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
799794
800795 const S = struct {
801796 const U = union(enum) {
......@@ -867,7 +862,6 @@ test "union no tag with struct member" {
867862 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
868863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
869864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
870 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
871865
872866 const Struct = struct {};
873867 const Union = union {
......@@ -1079,7 +1073,6 @@ test "@unionInit on union with tag but no fields" {
10791073 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10801074 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10811075 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1082 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10831076
10841077 const S = struct {
10851078 const Type = enum(u8) { no_op = 105 };
......@@ -1128,7 +1121,6 @@ test "global variable struct contains union initialized to non-most-aligned fiel
11281121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11291122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11301123 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1131 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11321124
11331125 const T = struct {
11341126 const U = union(enum) {
......@@ -1348,7 +1340,6 @@ test "union field ptr - zero sized payload" {
13481340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13491341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13501342 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1351 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13521343
13531344 const U = union {
13541345 foo: void,
......@@ -1363,7 +1354,6 @@ test "union field ptr - zero sized field" {
13631354 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13641355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13651356 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1366 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13671357
13681358 const U = union {
13691359 foo: void,