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 {...@@ -209,6 +209,10 @@ const DeclGen = struct {
209 /// See Object.type_map209 /// See Object.type_map
210 type_map: *TypeMap,210 type_map: *TypeMap,
211211
212 /// Child types of pointers that are currently in progress of being resolved. If a pointer
213 /// is already in this map, its recursive.
214 wip_pointers: std.AutoHashMapUnmanaged(struct { InternPool.Index, StorageClass }, CacheRef) = .{},
215
212 /// We need to keep track of result ids for block labels, as well as the 'incoming'216 /// We need to keep track of result ids for block labels, as well as the 'incoming'
213 /// blocks for a block.217 /// blocks for a block.
214 blocks: BlockMap = .{},218 blocks: BlockMap = .{},
...@@ -295,6 +299,7 @@ const DeclGen = struct {...@@ -295,6 +299,7 @@ const DeclGen = struct {
295 pub fn deinit(self: *DeclGen) void {299 pub fn deinit(self: *DeclGen) void {
296 self.args.deinit(self.gpa);300 self.args.deinit(self.gpa);
297 self.inst_results.deinit(self.gpa);301 self.inst_results.deinit(self.gpa);
302 self.wip_pointers.deinit(self.gpa);
298 self.blocks.deinit(self.gpa);303 self.blocks.deinit(self.gpa);
299 self.func.deinit(self.gpa);304 self.func.deinit(self.gpa);
300 self.base_line_stack.deinit(self.gpa);305 self.base_line_stack.deinit(self.gpa);
...@@ -358,8 +363,7 @@ const DeclGen = struct {...@@ -358,8 +363,7 @@ const DeclGen = struct {
358363
359 const mod = self.module;364 const mod = self.module;
360 const ty = mod.intern_pool.typeOf(val).toType();365 const ty = mod.intern_pool.typeOf(val).toType();
361 const ty_ref = try self.resolveType(ty, .indirect);366 const ptr_ty_ref = try self.ptrType(ty, storage_class);
362 const ptr_ty_ref = try self.spv.ptrType(ty_ref, storage_class);
363367
364 const var_id = self.spv.declPtr(spv_decl_index).result_id;368 const var_id = self.spv.declPtr(spv_decl_index).result_id;
365369
...@@ -582,66 +586,41 @@ const DeclGen = struct {...@@ -582,66 +586,41 @@ const DeclGen = struct {
582 }586 }
583587
584 /// Construct a struct at runtime.588 /// Construct a struct at runtime.
585 /// result_ty_ref must be a struct type.589 /// ty must be a struct type.
586 /// Constituents should be in `indirect` representation (as the elements of a struct should be).590 /// Constituents should be in `indirect` representation (as the elements of a struct should be).
587 /// Result is in `direct` representation.591 /// Result is in `direct` representation.
588 fn constructStruct(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {592 fn constructStruct(self: *DeclGen, ty: Type, types: []const Type, constituents: []const IdRef) !IdRef {
593 assert(types.len == constituents.len);
589 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'594 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
590 // operands are not constant.595 // operands are not constant.
591 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349596 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
592 // For now, just initialize the struct by setting the fields manually...597 // For now, just initialize the struct by setting the fields manually...
593 // TODO: Make this OpCompositeConstruct when we can598 // TODO: Make this OpCompositeConstruct when we can
594 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);599 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
595 const ptr_composite_id = self.spv.allocId();600 for (constituents, types, 0..) |constitent_id, member_ty, index| {
596 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{601 const ptr_member_ty_ref = try self.ptrType(member_ty, .Function);
597 .id_result_type = self.typeId(ptr_ty_ref),
598 .id_result = ptr_composite_id,
599 .storage_class = .Function,
600 });
601
602 const spv_composite_ty = self.spv.cache.lookup(result_ty_ref).struct_type;
603 const member_types = spv_composite_ty.member_types;
604
605 for (constituents, member_types, 0..) |constitent_id, member_ty_ref, index| {
606 const ptr_member_ty_ref = try self.spv.ptrType(member_ty_ref, .Function);
607 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});602 const ptr_id = try self.accessChain(ptr_member_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
608 try self.func.body.emit(self.spv.gpa, .OpStore, .{603 try self.func.body.emit(self.spv.gpa, .OpStore, .{
609 .pointer = ptr_id,604 .pointer = ptr_id,
610 .object = constitent_id,605 .object = constitent_id,
611 });606 });
612 }607 }
613 const result_id = self.spv.allocId();608 return try self.load(ty, ptr_composite_id, .{});
614 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
615 .id_result_type = self.typeId(result_ty_ref),
616 .id_result = result_id,
617 .pointer = ptr_composite_id,
618 });
619 return result_id;
620 }609 }
621610
622 /// Construct an array at runtime.611 /// Construct an array at runtime.
623 /// result_ty_ref must be an array type.612 /// ty must be an array type.
624 /// Constituents should be in `indirect` representation (as the elements of an array should be).613 /// Constituents should be in `indirect` representation (as the elements of an array should be).
625 /// Result is in `direct` representation.614 /// Result is in `direct` representation.
626 fn constructArray(self: *DeclGen, result_ty_ref: CacheRef, constituents: []const IdRef) !IdRef {615 fn constructArray(self: *DeclGen, ty: Type, constituents: []const IdRef) !IdRef {
627 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'616 // The Khronos LLVM-SPIRV translator crashes because it cannot construct structs which'
628 // operands are not constant.617 // operands are not constant.
629 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349618 // See https://github.com/KhronosGroup/SPIRV-LLVM-Translator/issues/1349
630 // For now, just initialize the struct by setting the fields manually...619 // For now, just initialize the struct by setting the fields manually...
631 // TODO: Make this OpCompositeConstruct when we can620 // TODO: Make this OpCompositeConstruct when we can
632 // TODO: Make this Function storage type621 const mod = self.module;
633 const ptr_ty_ref = try self.spv.ptrType(result_ty_ref, .Function);622 const ptr_composite_id = try self.alloc(ty, .{ .storage_class = .Function });
634 const ptr_composite_id = self.spv.allocId();623 const ptr_elem_ty_ref = try self.ptrType(ty.elemType2(mod), .Function);
635 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{
636 .id_result_type = self.typeId(ptr_ty_ref),
637 .id_result = ptr_composite_id,
638 .storage_class = .Function,
639 });
640
641 const spv_composite_ty = self.spv.cache.lookup(result_ty_ref).array_type;
642 const elem_ty_ref = spv_composite_ty.element_type;
643 const ptr_elem_ty_ref = try self.spv.ptrType(elem_ty_ref, .Function);
644
645 for (constituents, 0..) |constitent_id, index| {624 for (constituents, 0..) |constitent_id, index| {
646 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});625 const ptr_id = try self.accessChain(ptr_elem_ty_ref, ptr_composite_id, &.{@as(u32, @intCast(index))});
647 try self.func.body.emit(self.spv.gpa, .OpStore, .{626 try self.func.body.emit(self.spv.gpa, .OpStore, .{
...@@ -649,13 +628,8 @@ const DeclGen = struct {...@@ -649,13 +628,8 @@ const DeclGen = struct {
649 .object = constitent_id,628 .object = constitent_id,
650 });629 });
651 }630 }
652 const result_id = self.spv.allocId();631
653 try self.func.body.emit(self.spv.gpa, .OpLoad, .{632 return try self.load(ty, ptr_composite_id, .{});
654 .id_result_type = self.typeId(result_ty_ref),
655 .id_result = result_id,
656 .pointer = ptr_composite_id,
657 });
658 return result_id;
659 }633 }
660634
661 /// This function generates a load for a constant in direct (ie, non-memory) representation.635 /// This function generates a load for a constant in direct (ie, non-memory) representation.
...@@ -766,15 +740,18 @@ const DeclGen = struct {...@@ -766,15 +740,18 @@ const DeclGen = struct {
766 }.toValue();740 }.toValue();
767741
768 var constituents: [2]IdRef = undefined;742 var constituents: [2]IdRef = undefined;
743 var types: [2]Type = undefined;
769 if (eu_layout.error_first) {744 if (eu_layout.error_first) {
770 constituents[0] = try self.constant(err_ty, err_val, .indirect);745 constituents[0] = try self.constant(err_ty, err_val, .indirect);
771 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);746 constituents[1] = try self.constant(payload_ty, payload_val, .indirect);
747 types = .{ err_ty, payload_ty };
772 } else {748 } else {
773 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);749 constituents[0] = try self.constant(payload_ty, payload_val, .indirect);
774 constituents[1] = try self.constant(err_ty, err_val, .indirect);750 constituents[1] = try self.constant(err_ty, err_val, .indirect);
751 types = .{ payload_ty, err_ty };
775 }752 }
776753
777 return try self.constructStruct(result_ty_ref, &constituents);754 return try self.constructStruct(ty, &types, &constituents);
778 },755 },
779 .enum_tag => {756 .enum_tag => {
780 const int_val = try val.intFromEnum(ty, mod);757 const int_val = try val.intFromEnum(ty, mod);
...@@ -792,7 +769,11 @@ const DeclGen = struct {...@@ -792,7 +769,11 @@ const DeclGen = struct {
792 }769 }
793770
794 const len_id = try self.constant(Type.usize, ptr.len.toValue(), .indirect);771 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 );
796 },777 },
797 .opt => {778 .opt => {
798 const payload_ty = ty.optionalChild(mod);779 const payload_ty = ty.optionalChild(mod);
...@@ -819,7 +800,11 @@ const DeclGen = struct {...@@ -819,7 +800,11 @@ const DeclGen = struct {
819 else800 else
820 try self.spv.constUndef(try self.resolveType(payload_ty, .indirect));801 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 );
823 },808 },
824 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {809 .aggregate => |aggregate| switch (ip.indexToKey(ty.ip_index)) {
825 inline .array_type, .vector_type => |array_type, tag| {810 inline .array_type, .vector_type => |array_type, tag| {
...@@ -857,7 +842,7 @@ const DeclGen = struct {...@@ -857,7 +842,7 @@ const DeclGen = struct {
857 else => {},842 else => {},
858 }843 }
859844
860 return try self.constructArray(result_ty_ref, constituents);845 return try self.constructArray(ty, constituents);
861 },846 },
862 .struct_type => {847 .struct_type => {
863 const struct_type = mod.typeToStruct(ty).?;848 const struct_type = mod.typeToStruct(ty).?;
...@@ -865,6 +850,9 @@ const DeclGen = struct {...@@ -865,6 +850,9 @@ const DeclGen = struct {
865 return self.todo("packed struct constants", .{});850 return self.todo("packed struct constants", .{});
866 }851 }
867852
853 var types = std.ArrayList(Type).init(self.gpa);
854 defer types.deinit();
855
868 var constituents = std.ArrayList(IdRef).init(self.gpa);856 var constituents = std.ArrayList(IdRef).init(self.gpa);
869 defer constituents.deinit();857 defer constituents.deinit();
870858
...@@ -880,22 +868,23 @@ const DeclGen = struct {...@@ -880,22 +868,23 @@ const DeclGen = struct {
880 const field_val = try val.fieldValue(mod, field_index);868 const field_val = try val.fieldValue(mod, field_index);
881 const field_id = try self.constant(field_ty, field_val, .indirect);869 const field_id = try self.constant(field_ty, field_val, .indirect);
882870
871 try types.append(field_ty);
883 try constituents.append(field_id);872 try constituents.append(field_id);
884 }873 }
885874
886 return try self.constructStruct(result_ty_ref, constituents.items);875 return try self.constructStruct(ty, types.items, constituents.items);
887 },876 },
888 .anon_struct_type => unreachable, // TODO877 .anon_struct_type => unreachable, // TODO
889 else => unreachable,878 else => unreachable,
890 },879 },
891 .un => |un| {880 .un => |un| {
892 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;881 const active_field = ty.unionTagFieldIndex(un.tag.toValue(), mod).?;
893 const layout = self.unionLayout(ty, active_field);882 const union_obj = mod.typeToUnion(ty).?;
894 const payload = if (layout.active_field_size != 0)883 const field_ty = union_obj.field_types.get(ip)[active_field].toType();
895 try self.constant(layout.active_field_ty, un.val.toValue(), .indirect)884 const payload = if (field_ty.hasRuntimeBitsIgnoreComptime(mod))
885 try self.constant(field_ty, un.val.toValue(), .direct)
896 else886 else
897 null;887 null;
898
899 return try self.unionInit(ty, active_field, payload);888 return try self.unionInit(ty, active_field, payload);
900 },889 },
901 .memoized_call => unreachable,890 .memoized_call => unreachable,
...@@ -934,8 +923,7 @@ const DeclGen = struct {...@@ -934,8 +923,7 @@ const DeclGen = struct {
934923
935 // TODO: Can we consolidate this in ptrElemPtr?924 // TODO: Can we consolidate this in ptrElemPtr?
936 const elem_ty = parent_ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.925 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);926 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
938 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(parent_ptr_ty.ptrAddressSpace(mod)));
939927
940 if (elem_ptr_ty_ref == result_ty_ref) {928 if (elem_ptr_ty_ref == result_ty_ref) {
941 return elem_ptr_id;929 return elem_ptr_id;
...@@ -997,8 +985,7 @@ const DeclGen = struct {...@@ -997,8 +985,7 @@ const DeclGen = struct {
997 };985 };
998986
999 const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);987 const decl_id = try self.resolveAnonDecl(decl_val, actual_storage_class);
1000 const decl_ty_ref = try self.resolveType(decl_ty, .indirect);988 const decl_ptr_ty_ref = try self.ptrType(decl_ty, final_storage_class);
1001 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
1002989
1003 const ptr_id = switch (final_storage_class) {990 const ptr_id = switch (final_storage_class) {
1004 .Generic => blk: {991 .Generic => blk: {
...@@ -1054,8 +1041,7 @@ const DeclGen = struct {...@@ -1054,8 +1041,7 @@ const DeclGen = struct {
10541041
1055 const final_storage_class = spvStorageClass(decl.@"addrspace");1042 const final_storage_class = spvStorageClass(decl.@"addrspace");
10561043
1057 const decl_ty_ref = try self.resolveType(decl.ty, .indirect);1044 const decl_ptr_ty_ref = try self.ptrType(decl.ty, final_storage_class);
1058 const decl_ptr_ty_ref = try self.spv.ptrType(decl_ty_ref, final_storage_class);
10591045
1060 const ptr_id = switch (final_storage_class) {1046 const ptr_id = switch (final_storage_class) {
1061 .Generic => blk: {1047 .Generic => blk: {
...@@ -1123,29 +1109,52 @@ const DeclGen = struct {...@@ -1123,29 +1109,52 @@ const DeclGen = struct {
1123 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());1109 return try self.intType(.unsigned, self.getTarget().ptrBitWidth());
1124 }1110 }
11251111
1126 /// Generate a union type, optionally with a known field. If the tag alignment is greater1112 fn ptrType(self: *DeclGen, child_ty: Type, storage_class: StorageClass) !CacheRef {
1127 /// than that of the payload, a regular union (non-packed, with both tag and payload), will1113 const key = .{ child_ty.toIntern(), storage_class };
1128 /// be generated as follows:1114 const entry = try self.wip_pointers.getOrPut(self.gpa, key);
1129 /// If the active field is known: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:
1130 /// struct {1143 /// struct {
1131 /// tag: TagType,1144 /// tag: TagType,
1132 /// payload: ActivePayloadType,1145 /// payload: MostAlignedFieldType,
1133 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,1146 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1134 /// padding: [padding_size]u8,1147 /// padding: [padding_size]u8,
1135 /// }1148 /// }
1136 /// If the payload alignment is greater than that of the tag:1149 /// If the payload alignment is greater than that of the tag:
1137 /// struct {1150 /// struct {
1138 /// payload: ActivePayloadType,1151 /// payload: MostAlignedFieldType,
1139 /// payload_padding: [payload_size - @sizeOf(ActivePayloadType)]u8,1152 /// payload_padding: [payload_size - @sizeOf(MostAlignedFieldType)]u8,
1140 /// tag: TagType,1153 /// tag: TagType,
1141 /// padding: [padding_size]u8,1154 /// padding: [padding_size]u8,
1142 /// }1155 /// }
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.
1145 /// If any of the fields' size is 0, it will be omitted.1156 /// 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, the1157 fn resolveUnionType(self: *DeclGen, ty: Type) !CacheRef {
1147 /// resulting struct will be *underaligned*.
1148 fn resolveUnionType(self: *DeclGen, ty: Type, maybe_active_field: ?usize) !CacheRef {
1149 const mod = self.module;1158 const mod = self.module;
1150 const ip = &mod.intern_pool;1159 const ip = &mod.intern_pool;
1151 const union_obj = mod.typeToUnion(ty).?;1160 const union_obj = mod.typeToUnion(ty).?;
...@@ -1154,17 +1163,13 @@ const DeclGen = struct {...@@ -1154,17 +1163,13 @@ const DeclGen = struct {
1154 return self.todo("packed union types", .{});1163 return self.todo("packed union types", .{});
1155 }1164 }
11561165
1157 const layout = self.unionLayout(ty, maybe_active_field);1166 const layout = self.unionLayout(ty);
11581167 if (!layout.has_payload) {
1159 if (layout.payload_size == 0) {
1160 // No payload, so represent this as just the tag type.1168 // No payload, so represent this as just the tag type.
1161 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);1169 return try self.resolveType(union_obj.enum_tag_ty.toType(), .indirect);
1162 }1170 }
11631171
1164 // TODO: We need to add the active field to the key, somehow.1172 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1165 if (maybe_active_field == null) {
1166 if (self.type_map.get(ty.toIntern())) |info| return info.ty_ref;
1167 }
11681173
1169 var member_types: [4]CacheRef = undefined;1174 var member_types: [4]CacheRef = undefined;
1170 var member_names: [4]CacheString = undefined;1175 var member_names: [4]CacheString = undefined;
...@@ -1177,10 +1182,10 @@ const DeclGen = struct {...@@ -1177,10 +1182,10 @@ const DeclGen = struct {
1177 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");1182 member_names[layout.tag_index] = try self.spv.resolveString("(tag)");
1178 }1183 }
11791184
1180 if (layout.active_field_size != 0) {1185 if (layout.payload_size != 0) {
1181 const active_payload_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);1186 const payload_ty_ref = try self.resolveType(layout.payload_ty, .indirect);
1182 member_types[layout.active_field_index] = active_payload_ty_ref;1187 member_types[layout.payload_index] = payload_ty_ref;
1183 member_names[layout.active_field_index] = try self.spv.resolveString("(payload)");1188 member_names[layout.payload_index] = try self.spv.resolveString("(payload)");
1184 }1189 }
11851190
1186 if (layout.payload_padding_size != 0) {1191 if (layout.payload_padding_size != 0) {
...@@ -1201,9 +1206,7 @@ const DeclGen = struct {...@@ -1201,9 +1206,7 @@ const DeclGen = struct {
1201 .member_names = member_names[0..layout.total_fields],1206 .member_names = member_names[0..layout.total_fields],
1202 } });1207 } });
12031208
1204 if (maybe_active_field == null) {1209 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1205 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1206 }
1207 return ty_ref;1210 return ty_ref;
1208 }1211 }
12091212
...@@ -1351,12 +1354,12 @@ const DeclGen = struct {...@@ -1351,12 +1354,12 @@ const DeclGen = struct {
1351 .Pointer => {1354 .Pointer => {
1352 const ptr_info = ty.ptrInfo(mod);1355 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
1354 const storage_class = spvStorageClass(ptr_info.flags.address_space);1360 const storage_class = spvStorageClass(ptr_info.flags.address_space);
1355 const child_ty_ref = try self.resolveType(ptr_info.child.toType(), .indirect);1361 const ptr_ty_ref = try self.ptrType(ptr_info.child.toType(), storage_class);
1356 const ptr_ty_ref = try self.spv.resolve(.{ .ptr_type = .{1362
1357 .storage_class = storage_class,
1358 .child_type = child_ty_ref,
1359 } });
1360 if (ptr_info.flags.size != .Slice) {1363 if (ptr_info.flags.size != .Slice) {
1361 return ptr_ty_ref;1364 return ptr_ty_ref;
1362 }1365 }
...@@ -1471,7 +1474,7 @@ const DeclGen = struct {...@@ -1471,7 +1474,7 @@ const DeclGen = struct {
1471 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });1474 try self.type_map.put(self.gpa, ty.toIntern(), .{ .ty_ref = ty_ref });
1472 return ty_ref;1475 return ty_ref;
1473 },1476 },
1474 .Union => return try self.resolveUnionType(ty, null),1477 .Union => return try self.resolveUnionType(ty),
1475 .ErrorSet => return try self.intType(.unsigned, 16),1478 .ErrorSet => return try self.intType(.unsigned, 16),
1476 .ErrorUnion => {1479 .ErrorUnion => {
1477 const payload_ty = ty.errorUnionPayload(mod);1480 const payload_ty = ty.errorUnionPayload(mod);
...@@ -1585,14 +1588,16 @@ const DeclGen = struct {...@@ -1585,14 +1588,16 @@ const DeclGen = struct {
1585 }1588 }
15861589
1587 const UnionLayout = struct {1590 const UnionLayout = struct {
1588 active_field: u32,1591 /// If false, this union is represented
1589 active_field_ty: Type,1592 /// by only an integer of the tag type.
1590 payload_size: u32,1593 has_payload: bool,
1591
1592 tag_size: u32,1594 tag_size: u32,
1593 tag_index: u32,1595 tag_index: u32,
1594 active_field_size: u32,1596 /// Note: This is the size of the payload type itself, NOT the size of the ENTIRE payload.
1595 active_field_index: u32,1597 /// Use `has_payload` instead!!
1598 payload_ty: Type,
1599 payload_size: u32,
1600 payload_index: u32,
1596 payload_padding_size: u32,1601 payload_padding_size: u32,
1597 payload_padding_index: u32,1602 payload_padding_index: u32,
1598 padding_size: u32,1603 padding_size: u32,
...@@ -1600,23 +1605,19 @@ const DeclGen = struct {...@@ -1600,23 +1605,19 @@ const DeclGen = struct {
1600 total_fields: u32,1605 total_fields: u32,
1601 };1606 };
16021607
1603 fn unionLayout(self: *DeclGen, ty: Type, maybe_active_field: ?usize) UnionLayout {1608 fn unionLayout(self: *DeclGen, ty: Type) UnionLayout {
1604 const mod = self.module;1609 const mod = self.module;
1605 const ip = &mod.intern_pool;1610 const ip = &mod.intern_pool;
1606 const layout = ty.unionGetLayout(self.module);1611 const layout = ty.unionGetLayout(self.module);
1607 const union_obj = mod.typeToUnion(ty).?;1612 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
1612 var union_layout = UnionLayout{1614 var union_layout = UnionLayout{
1613 .active_field = @intCast(active_field),1615 .has_payload = layout.payload_size != 0,
1614 .active_field_ty = active_field_ty,
1615 .payload_size = @intCast(layout.payload_size),
1616 .tag_size = @intCast(layout.tag_size),1616 .tag_size = @intCast(layout.tag_size),
1617 .tag_index = undefined,1617 .tag_index = undefined,
1618 .active_field_size = undefined,1618 .payload_ty = undefined,
1619 .active_field_index = undefined,1619 .payload_size = undefined,
1620 .payload_index = undefined,
1620 .payload_padding_size = undefined,1621 .payload_padding_size = undefined,
1621 .payload_padding_index = undefined,1622 .payload_padding_index = undefined,
1622 .padding_size = @intCast(layout.padding),1623 .padding_size = @intCast(layout.padding),
...@@ -1624,11 +1625,16 @@ const DeclGen = struct {...@@ -1624,11 +1625,16 @@ const DeclGen = struct {
1624 .total_fields = undefined,1625 .total_fields = undefined,
1625 };1626 };
16261627
1627 union_layout.active_field_size = if (active_field_ty.hasRuntimeBitsIgnoreComptime(mod))1628 if (union_layout.has_payload) {
1628 @intCast(active_field_ty.abiSize(mod))1629 const most_aligned_field = layout.most_aligned_field;
1629 else1630 const most_aligned_field_ty = union_obj.field_types.get(ip)[most_aligned_field].toType();
1630 0;1631 union_layout.payload_ty = most_aligned_field_ty;
1631 union_layout.payload_padding_size = @intCast(layout.payload_size - union_layout.active_field_size);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
1633 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);1639 const tag_first = layout.tag_align.compare(.gte, layout.payload_align);
1634 var field_index: u32 = 0;1640 var field_index: u32 = 0;
...@@ -1638,8 +1644,8 @@ const DeclGen = struct {...@@ -1638,8 +1644,8 @@ const DeclGen = struct {
1638 field_index += 1;1644 field_index += 1;
1639 }1645 }
16401646
1641 if (union_layout.active_field_size != 0) {1647 if (union_layout.payload_size != 0) {
1642 union_layout.active_field_index = field_index;1648 union_layout.payload_index = field_index;
1643 field_index += 1;1649 field_index += 1;
1644 }1650 }
16451651
...@@ -1683,7 +1689,7 @@ const DeclGen = struct {...@@ -1683,7 +1689,7 @@ const DeclGen = struct {
1683 /// the name of an error in the text executor.1689 /// the name of an error in the text executor.
1684 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {1690 fn generateTestEntryPoint(self: *DeclGen, name: []const u8, spv_test_decl_index: SpvModule.Decl.Index) !void {
1685 const anyerror_ty_ref = try self.resolveType(Type.anyerror, .direct);1691 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);
1687 const void_ty_ref = try self.resolveType(Type.void, .direct);1693 const void_ty_ref = try self.resolveType(Type.void, .direct);
16881694
1689 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{1695 const kernel_proto_ty_ref = try self.spv.resolve(.{ .function_type = .{
...@@ -1718,6 +1724,7 @@ const DeclGen = struct {...@@ -1718,6 +1724,7 @@ const DeclGen = struct {
1718 .id_result = error_id,1724 .id_result = error_id,
1719 .function = test_id,1725 .function = test_id,
1720 });1726 });
1727 // Note: Convert to direct not required.
1721 try section.emit(self.spv.gpa, .OpStore, .{1728 try section.emit(self.spv.gpa, .OpStore, .{
1722 .pointer = p_error_id,1729 .pointer = p_error_id,
1723 .object = error_id,1730 .object = error_id,
...@@ -1822,8 +1829,7 @@ const DeclGen = struct {...@@ -1822,8 +1829,7 @@ const DeclGen = struct {
1822 else => final_storage_class,1829 else => final_storage_class,
1823 };1830 };
18241831
1825 const ty_ref = try self.resolveType(decl.ty, .indirect);1832 const ptr_ty_ref = try self.ptrType(decl.ty, actual_storage_class);
1826 const ptr_ty_ref = try self.spv.ptrType(ty_ref, actual_storage_class);
18271833
1828 const begin = self.spv.beginGlobal();1834 const begin = self.spv.beginGlobal();
1829 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{1835 try self.spv.globals.section.emit(self.spv.gpa, .OpVariable, .{
...@@ -1928,11 +1934,15 @@ const DeclGen = struct {...@@ -1928,11 +1934,15 @@ const DeclGen = struct {
1928 return try self.convertToDirect(result_ty, result_id);1934 return try self.convertToDirect(result_ty, result_id);
1929 }1935 }
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 {
1932 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);1942 const indirect_value_ty_ref = try self.resolveType(value_ty, .indirect);
1933 const result_id = self.spv.allocId();1943 const result_id = self.spv.allocId();
1934 const access = spec.MemoryAccess.Extended{1944 const access = spec.MemoryAccess.Extended{
1935 .Volatile = is_volatile,1945 .Volatile = options.is_volatile,
1936 };1946 };
1937 try self.func.body.emit(self.spv.gpa, .OpLoad, .{1947 try self.func.body.emit(self.spv.gpa, .OpLoad, .{
1938 .id_result_type = self.typeId(indirect_value_ty_ref),1948 .id_result_type = self.typeId(indirect_value_ty_ref),
...@@ -1943,10 +1953,10 @@ const DeclGen = struct {...@@ -1943,10 +1953,10 @@ const DeclGen = struct {
1943 return try self.convertToDirect(value_ty, result_id);1953 return try self.convertToDirect(value_ty, result_id);
1944 }1954 }
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 {
1947 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);1957 const indirect_value_id = try self.convertToIndirect(value_ty, value_id);
1948 const access = spec.MemoryAccess.Extended{1958 const access = spec.MemoryAccess.Extended{
1949 .Volatile = is_volatile,1959 .Volatile = options.is_volatile,
1950 };1960 };
1951 try self.func.body.emit(self.spv.gpa, .OpStore, .{1961 try self.func.body.emit(self.spv.gpa, .OpStore, .{
1952 .pointer = ptr_id,1962 .pointer = ptr_id,
...@@ -2118,9 +2128,7 @@ const DeclGen = struct {...@@ -2118,9 +2128,7 @@ const DeclGen = struct {
2118 constituent.* = try self.convertToIndirect(child_ty, result_id);2128 constituent.* = try self.convertToIndirect(child_ty, result_id);
2119 }2129 }
21202130
2121 const result_ty = try self.resolveType(child_ty, .indirect);2131 return try self.constructArray(ty, constituents);
2122 const result_ty_ref = try self.spv.arrayType(vector_len, result_ty);
2123 return try self.constructArray(result_ty_ref, constituents);
2124 }2132 }
21252133
2126 const result_id = self.spv.allocId();2134 const result_id = self.spv.allocId();
...@@ -2181,7 +2189,7 @@ const DeclGen = struct {...@@ -2181,7 +2189,7 @@ const DeclGen = struct {
21812189
2182 const info = try self.arithmeticTypeInfo(result_ty);2190 const info = try self.arithmeticTypeInfo(result_ty);
2183 // TODO: Use fmin for OpenCL2191 // 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);
2185 const selection_id = switch (info.class) {2193 const selection_id = switch (info.class) {
2186 .float => blk: {2194 .float => blk: {
2187 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,2195 // cmp uses OpFOrd. When we have 0 [<>] nan this returns false,
...@@ -2316,7 +2324,7 @@ const DeclGen = struct {...@@ -2316,7 +2324,7 @@ const DeclGen = struct {
2316 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);2324 constituent.* = try self.arithOp(child_ty, lhs_index_id, rhs_index_id, fop, sop, uop, modular);
2317 }2325 }
23182326
2319 return self.constructArray(result_ty_ref, constituents);2327 return self.constructArray(ty, constituents);
2320 }2328 }
23212329
2322 // Binary operations are generally applicable to both scalar and vector operations2330 // Binary operations are generally applicable to both scalar and vector operations
...@@ -2472,11 +2480,11 @@ const DeclGen = struct {...@@ -2472,11 +2480,11 @@ const DeclGen = struct {
2472 // Construct the struct that Zig wants as result.2480 // Construct the struct that Zig wants as result.
2473 // The value should already be the correct type.2481 // The value should already be the correct type.
2474 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);2482 const ov_id = try self.intFromBool(ov_ty_ref, overflowed_id);
2475 const result_ty_ref = try self.resolveType(result_ty, .direct);2483 return try self.constructStruct(
2476 return try self.constructStruct(result_ty_ref, &.{2484 result_ty,
2477 value_id,2485 &.{ operand_ty, ov_ty },
2478 ov_id,2486 &.{ value_id, ov_id },
2479 });2487 );
2480 }2488 }
24812489
2482 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2490 fn airShuffle(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -2634,6 +2642,7 @@ const DeclGen = struct {...@@ -2634,6 +2642,7 @@ const DeclGen = struct {
2634 fn cmp(2642 fn cmp(
2635 self: *DeclGen,2643 self: *DeclGen,
2636 op: std.math.CompareOperator,2644 op: std.math.CompareOperator,
2645 result_ty: Type,
2637 ty: Type,2646 ty: Type,
2638 lhs_id: IdRef,2647 lhs_id: IdRef,
2639 rhs_id: IdRef,2648 rhs_id: IdRef,
...@@ -2674,7 +2683,7 @@ const DeclGen = struct {...@@ -2674,7 +2683,7 @@ const DeclGen = struct {
2674 if (ty.optionalReprIsPayload(mod)) {2683 if (ty.optionalReprIsPayload(mod)) {
2675 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));2684 assert(payload_ty.hasRuntimeBitsIgnoreComptime(mod));
2676 assert(!payload_ty.isSlice(mod));2685 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);
2678 }2687 }
26792688
2680 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))2689 const lhs_valid_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
...@@ -2687,7 +2696,7 @@ const DeclGen = struct {...@@ -2687,7 +2696,7 @@ const DeclGen = struct {
2687 else2696 else
2688 try self.convertToDirect(Type.bool, rhs_id);2697 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);
2691 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {2700 if (!payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
2692 return valid_cmp_id;2701 return valid_cmp_id;
2693 }2702 }
...@@ -2698,7 +2707,7 @@ const DeclGen = struct {...@@ -2698,7 +2707,7 @@ const DeclGen = struct {
2698 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);2707 const lhs_pl_id = try self.extractField(payload_ty, lhs_id, 0);
2699 const rhs_pl_id = try self.extractField(payload_ty, rhs_id, 0);2708 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
2703 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl2712 // op == .eq => lhs_valid == rhs_valid && lhs_pl == rhs_pl
2704 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl2713 // op == .neq => lhs_valid != rhs_valid || lhs_pl != rhs_pl
...@@ -2720,7 +2729,6 @@ const DeclGen = struct {...@@ -2720,7 +2729,6 @@ const DeclGen = struct {
2720 .Vector => {2729 .Vector => {
2721 const child_ty = ty.childType(mod);2730 const child_ty = ty.childType(mod);
2722 const vector_len = ty.vectorLen(mod);2731 const vector_len = ty.vectorLen(mod);
2723 const bool_ty_ref_indirect = try self.resolveType(Type.bool, .indirect);
27242732
2725 var constituents = try self.gpa.alloc(IdRef, vector_len);2733 var constituents = try self.gpa.alloc(IdRef, vector_len);
2726 defer self.gpa.free(constituents);2734 defer self.gpa.free(constituents);
...@@ -2728,12 +2736,11 @@ const DeclGen = struct {...@@ -2728,12 +2736,11 @@ const DeclGen = struct {
2728 for (constituents, 0..) |*constituent, i| {2736 for (constituents, 0..) |*constituent, i| {
2729 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));2737 const lhs_index_id = try self.extractField(child_ty, cmp_lhs_id, @intCast(i));
2730 const rhs_index_id = try self.extractField(child_ty, cmp_rhs_id, @intCast(i));2738 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);
2732 constituent.* = try self.convertToIndirect(Type.bool, result_id);2740 constituent.* = try self.convertToIndirect(Type.bool, result_id);
2733 }2741 }
27342742
2735 const result_ty_ref = try self.spv.arrayType(vector_len, bool_ty_ref_indirect);2743 return try self.constructArray(result_ty, constituents);
2736 return try self.constructArray(result_ty_ref, constituents);
2737 },2744 },
2738 else => unreachable,2745 else => unreachable,
2739 };2746 };
...@@ -2806,8 +2813,9 @@ const DeclGen = struct {...@@ -2806,8 +2813,9 @@ const DeclGen = struct {
2806 const lhs_id = try self.resolve(bin_op.lhs);2813 const lhs_id = try self.resolve(bin_op.lhs);
2807 const rhs_id = try self.resolve(bin_op.rhs);2814 const rhs_id = try self.resolve(bin_op.rhs);
2808 const ty = self.typeOf(bin_op.lhs);2815 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);
2811 }2819 }
28122820
2813 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2821 fn airVectorCmp(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -2819,8 +2827,9 @@ const DeclGen = struct {...@@ -2819,8 +2827,9 @@ const DeclGen = struct {
2819 const rhs_id = try self.resolve(vec_cmp.rhs);2827 const rhs_id = try self.resolve(vec_cmp.rhs);
2820 const op = vec_cmp.compareOperator();2828 const op = vec_cmp.compareOperator();
2821 const ty = self.typeOf(vec_cmp.lhs);2829 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);
2824 }2833 }
28252834
2826 fn bitCast(2835 fn bitCast(
...@@ -2865,23 +2874,17 @@ const DeclGen = struct {...@@ -2865,23 +2874,17 @@ const DeclGen = struct {
2865 return result_id;2874 return result_id;
2866 }2875 }
28672876
2868 const src_ptr_ty_ref = try self.spv.ptrType(src_ty_ref, .Function);2877 const dst_ptr_ty_ref = try self.ptrType(dst_ty, .Function);
2869 const dst_ptr_ty_ref = try self.spv.ptrType(dst_ty_ref, .Function);
28702878
2871 const tmp_id = self.spv.allocId();2879 const tmp_id = try self.alloc(src_ty, .{ .storage_class = .Function });
2872 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{2880 try self.store(src_ty, tmp_id, src_id, .{});
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);
2878 const casted_ptr_id = self.spv.allocId();2881 const casted_ptr_id = self.spv.allocId();
2879 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{2882 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
2880 .id_result_type = self.typeId(dst_ptr_ty_ref),2883 .id_result_type = self.typeId(dst_ptr_ty_ref),
2881 .id_result = casted_ptr_id,2884 .id_result = casted_ptr_id,
2882 .operand = tmp_id,2885 .operand = tmp_id,
2883 });2886 });
2884 return try self.load(dst_ty, casted_ptr_id, false);2887 return try self.load(dst_ty, casted_ptr_id, .{});
2885 }2888 }
28862889
2887 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {2890 fn airBitCast(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3060,7 +3063,6 @@ const DeclGen = struct {...@@ -3060,7 +3063,6 @@ const DeclGen = struct {
3060 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);3063 const elem_ptr_ty = slice_ty.slicePtrFieldType(mod);
30613064
3062 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);3065 const elem_ptr_ty_ref = try self.resolveType(elem_ptr_ty, .direct);
3063 const slice_ty_ref = try self.resolveType(slice_ty, .direct);
3064 const size_ty_ref = try self.sizeType();3066 const size_ty_ref = try self.sizeType();
30653067
3066 const array_ptr_id = try self.resolve(ty_op.operand);3068 const array_ptr_id = try self.resolve(ty_op.operand);
...@@ -3073,7 +3075,11 @@ const DeclGen = struct {...@@ -3073,7 +3075,11 @@ const DeclGen = struct {
3073 // Convert the pointer-to-array to a pointer to the first element.3075 // Convert the pointer-to-array to a pointer to the first element.
3074 try self.accessChain(elem_ptr_ty_ref, array_ptr_id, &.{0});3076 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 );
3077 }3083 }
30783084
3079 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3085 fn airSlice(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3083,13 +3089,16 @@ const DeclGen = struct {...@@ -3083,13 +3089,16 @@ const DeclGen = struct {
3083 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;3089 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
3084 const ptr_id = try self.resolve(bin_op.lhs);3090 const ptr_id = try self.resolve(bin_op.lhs);
3085 const len_id = try self.resolve(bin_op.rhs);3091 const len_id = try self.resolve(bin_op.rhs);
3092 const ptr_ty = self.typeOf(bin_op.lhs);
3086 const slice_ty = self.typeOfIndex(inst);3093 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, &.{3095 // Note: Types should not need to be converted to direct, these types
3090 ptr_id, // Note: Type should not need to be converted to direct.3096 // dont need to be converted.
3091 len_id, // Note: Type should not need to be converted to direct.3097 return try self.constructStruct(
3092 });3098 slice_ty,
3099 &.{ ptr_ty, Type.usize },
3100 &.{ ptr_id, len_id },
3101 );
3093 }3102 }
30943103
3095 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3104 fn airAggregateInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3099,7 +3108,6 @@ const DeclGen = struct {...@@ -3099,7 +3108,6 @@ const DeclGen = struct {
3099 const ip = &mod.intern_pool;3108 const ip = &mod.intern_pool;
3100 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;3109 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
3101 const result_ty = self.typeOfIndex(inst);3110 const result_ty = self.typeOfIndex(inst);
3102 const result_ty_ref = try self.resolveType(result_ty, .direct);
3103 const len: usize = @intCast(result_ty.arrayLen(mod));3111 const len: usize = @intCast(result_ty.arrayLen(mod));
3104 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);3112 const elements: []const Air.Inst.Ref = @ptrCast(self.air.extra[ty_pl.payload..][0..len]);
31053113
...@@ -3111,6 +3119,8 @@ const DeclGen = struct {...@@ -3111,6 +3119,8 @@ const DeclGen = struct {
3111 unreachable; // TODO3119 unreachable; // TODO
3112 }3120 }
31133121
3122 const types = try self.gpa.alloc(Type, elements.len);
3123 defer self.gpa.free(types);
3114 const constituents = try self.gpa.alloc(IdRef, elements.len);3124 const constituents = try self.gpa.alloc(IdRef, elements.len);
3115 defer self.gpa.free(constituents);3125 defer self.gpa.free(constituents);
3116 var index: usize = 0;3126 var index: usize = 0;
...@@ -3122,6 +3132,7 @@ const DeclGen = struct {...@@ -3122,6 +3132,7 @@ const DeclGen = struct {
3122 assert(field_ty.toType().hasRuntimeBits(mod));3132 assert(field_ty.toType().hasRuntimeBits(mod));
31233133
3124 const id = try self.resolve(element);3134 const id = try self.resolve(element);
3135 types[index] = field_ty.toType();
3125 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);3136 constituents[index] = try self.convertToIndirect(field_ty.toType(), id);
3126 index += 1;3137 index += 1;
3127 }3138 }
...@@ -3135,6 +3146,7 @@ const DeclGen = struct {...@@ -3135,6 +3146,7 @@ const DeclGen = struct {
3135 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));3146 assert(field_ty.hasRuntimeBitsIgnoreComptime(mod));
31363147
3137 const id = try self.resolve(element);3148 const id = try self.resolve(element);
3149 types[index] = field_ty;
3138 constituents[index] = try self.convertToIndirect(field_ty, id);3150 constituents[index] = try self.convertToIndirect(field_ty, id);
3139 index += 1;3151 index += 1;
3140 }3152 }
...@@ -3142,7 +3154,11 @@ const DeclGen = struct {...@@ -3142,7 +3154,11 @@ const DeclGen = struct {
3142 else => unreachable,3154 else => unreachable,
3143 }3155 }
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 );
3146 },3162 },
3147 .Array => {3163 .Array => {
3148 const array_info = result_ty.arrayInfo(mod);3164 const array_info = result_ty.arrayInfo(mod);
...@@ -3159,7 +3175,7 @@ const DeclGen = struct {...@@ -3159,7 +3175,7 @@ const DeclGen = struct {
3159 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);3175 elem_ids[n_elems - 1] = try self.constant(array_info.elem_type, sentinel_val, .indirect);
3160 }3176 }
31613177
3162 return try self.constructArray(result_ty_ref, elem_ids);3178 return try self.constructArray(result_ty, elem_ids);
3163 },3179 },
3164 else => unreachable,3180 else => unreachable,
3165 }3181 }
...@@ -3244,15 +3260,14 @@ const DeclGen = struct {...@@ -3244,15 +3260,14 @@ const DeclGen = struct {
32443260
3245 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);3261 const slice_ptr = try self.extractField(ptr_ty, slice_id, 0);
3246 const elem_ptr = try self.ptrAccessChain(ptr_ty_ref, slice_ptr, index_id, &.{});3262 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) });
3248 }3264 }
32493265
3250 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {3266 fn ptrElemPtr(self: *DeclGen, ptr_ty: Type, ptr_id: IdRef, index_id: IdRef) !IdRef {
3251 const mod = self.module;3267 const mod = self.module;
3252 // Construct new pointer type for the resulting pointer3268 // Construct new pointer type for the resulting pointer
3253 const elem_ty = ptr_ty.elemType2(mod); // use elemType() so that we get T for *[N]T.3269 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);3270 const elem_ptr_ty_ref = try self.ptrType(elem_ty, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
3255 const elem_ptr_ty_ref = try self.spv.ptrType(elem_ty_ref, spvStorageClass(ptr_ty.ptrAddressSpace(mod)));
3256 if (ptr_ty.isSinglePointer(mod)) {3271 if (ptr_ty.isSinglePointer(mod)) {
3257 // Pointer-to-array. In this case, the resulting pointer is not of the same type3272 // Pointer-to-array. In this case, the resulting pointer is not of the same type
3258 // as the ptr_ty (we want a *T, not a *[N]T), and hence we need to use accessChain.3273 // 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 {...@@ -3288,9 +3303,7 @@ const DeclGen = struct {
3288 const mod = self.module;3303 const mod = self.module;
3289 const bin_op = self.air.instructions.items(.data)[inst].bin_op;3304 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
3290 const array_ty = self.typeOf(bin_op.lhs);3305 const array_ty = self.typeOf(bin_op.lhs);
3291 const array_ty_ref = try self.resolveType(array_ty, .direct);
3292 const elem_ty = array_ty.childType(mod);3306 const elem_ty = array_ty.childType(mod);
3293 const elem_ty_ref = try self.resolveType(elem_ty, .indirect);
3294 const array_id = try self.resolve(bin_op.lhs);3307 const array_id = try self.resolve(bin_op.lhs);
3295 const index_id = try self.resolve(bin_op.rhs);3308 const index_id = try self.resolve(bin_op.rhs);
32963309
...@@ -3298,22 +3311,12 @@ const DeclGen = struct {...@@ -3298,22 +3311,12 @@ const DeclGen = struct {
3298 // For now, just generate a temporary and use that.3311 // For now, just generate a temporary and use that.
3299 // TODO: This backend probably also should use isByRef from llvm...3312 // 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);3314 const elem_ptr_ty_ref = try self.ptrType(elem_ty, .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 });
33143315
3316 const tmp_id = try self.alloc(array_ty, .{ .storage_class = .Function });
3317 try self.store(array_ty, tmp_id, array_id, .{});
3315 const elem_ptr_id = try self.accessChainId(elem_ptr_ty_ref, tmp_id, &.{index_id});3318 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, .{});
3317 }3320 }
33183321
3319 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3322 fn airPtrElemVal(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3326,7 +3329,7 @@ const DeclGen = struct {...@@ -3326,7 +3329,7 @@ const DeclGen = struct {
3326 const ptr_id = try self.resolve(bin_op.lhs);3329 const ptr_id = try self.resolve(bin_op.lhs);
3327 const index_id = try self.resolve(bin_op.rhs);3330 const index_id = try self.resolve(bin_op.rhs);
3328 const elem_ptr_id = try self.ptrElemPtr(ptr_ty, ptr_id, index_id);3331 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) });
3330 }3333 }
33313334
3332 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {3335 fn airSetUnionTag(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3334,22 +3337,21 @@ const DeclGen = struct {...@@ -3334,22 +3337,21 @@ const DeclGen = struct {
3334 const bin_op = self.air.instructions.items(.data)[inst].bin_op;3337 const bin_op = self.air.instructions.items(.data)[inst].bin_op;
3335 const un_ptr_ty = self.typeOf(bin_op.lhs);3338 const un_ptr_ty = self.typeOf(bin_op.lhs);
3336 const un_ty = un_ptr_ty.childType(mod);3339 const un_ty = un_ptr_ty.childType(mod);
3337 const layout = self.unionLayout(un_ty, null);3340 const layout = self.unionLayout(un_ty);
33383341
3339 if (layout.tag_size == 0) return;3342 if (layout.tag_size == 0) return;
33403343
3341 const tag_ty = un_ty.unionTagTypeSafety(mod).?;3344 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
3342 const tag_ty_ref = try self.resolveType(tag_ty, .indirect);3345 const tag_ptr_ty_ref = try self.ptrType(tag_ty, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
3343 const tag_ptr_ty_ref = try self.spv.ptrType(tag_ty_ref, spvStorageClass(un_ptr_ty.ptrAddressSpace(mod)));
33443346
3345 const union_ptr_id = try self.resolve(bin_op.lhs);3347 const union_ptr_id = try self.resolve(bin_op.lhs);
3346 const new_tag_id = try self.resolve(bin_op.rhs);3348 const new_tag_id = try self.resolve(bin_op.rhs);
33473349
3348 if (layout.payload_size == 0) {3350 if (!layout.has_payload) {
3349 try self.store(tag_ty, union_ptr_id, new_tag_id, un_ptr_ty.isVolatilePtr(mod));3351 try self.store(tag_ty, union_ptr_id, new_tag_id, .{ .is_volatile = un_ptr_ty.isVolatilePtr(mod) });
3350 } else {3352 } else {
3351 const ptr_id = try self.accessChain(tag_ptr_ty_ref, union_ptr_id, &.{layout.tag_index});3353 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) });
3353 }3355 }
3354 }3356 }
33553357
...@@ -3360,11 +3362,11 @@ const DeclGen = struct {...@@ -3360,11 +3362,11 @@ const DeclGen = struct {
3360 const un_ty = self.typeOf(ty_op.operand);3362 const un_ty = self.typeOf(ty_op.operand);
33613363
3362 const mod = self.module;3364 const mod = self.module;
3363 const layout = self.unionLayout(un_ty, null);3365 const layout = self.unionLayout(un_ty);
3364 if (layout.tag_size == 0) return null;3366 if (layout.tag_size == 0) return null;
33653367
3366 const union_handle = try self.resolve(ty_op.operand);3368 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
3369 const tag_ty = un_ty.unionTagTypeSafety(mod).?;3371 const tag_ty = un_ty.unionTagTypeSafety(mod).?;
3370 return try self.extractField(tag_ty, union_handle, layout.tag_index);3372 return try self.extractField(tag_ty, union_handle, layout.tag_index);
...@@ -3377,8 +3379,8 @@ const DeclGen = struct {...@@ -3377,8 +3379,8 @@ const DeclGen = struct {
3377 payload: ?IdRef,3379 payload: ?IdRef,
3378 ) !IdRef {3380 ) !IdRef {
3379 // To initialize a union, generate a temporary variable with the3381 // To initialize a union, generate a temporary variable with the
3380 // type that has the right field active, then pointer-cast and store3382 // union type, then get the field pointer and pointer-cast it to the
3381 // the active field, and finally load and return the entire union.3383 // right type to store it. Finally load the entire union.
33823384
3383 const mod = self.module;3385 const mod = self.module;
3384 const ip = &mod.intern_pool;3386 const ip = &mod.intern_pool;
...@@ -3389,7 +3391,7 @@ const DeclGen = struct {...@@ -3389,7 +3391,7 @@ const DeclGen = struct {
3389 }3391 }
33903392
3391 const maybe_tag_ty = ty.unionTagTypeSafety(mod);3393 const maybe_tag_ty = ty.unionTagTypeSafety(mod);
3392 const layout = self.unionLayout(ty, active_field);3394 const layout = self.unionLayout(ty);
33933395
3394 const tag_int = if (layout.tag_size != 0) blk: {3396 const tag_int = if (layout.tag_size != 0) blk: {
3395 const tag_ty = maybe_tag_ty.?;3397 const tag_ty = maybe_tag_ty.?;
...@@ -3400,42 +3402,34 @@ const DeclGen = struct {...@@ -3400,42 +3402,34 @@ const DeclGen = struct {
3400 break :blk tag_int_val.toUnsignedInt(mod);3402 break :blk tag_int_val.toUnsignedInt(mod);
3401 } else 0;3403 } else 0;
34023404
3403 if (layout.payload_size == 0) {3405 if (!layout.has_payload) {
3404 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);3406 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);
3405 return try self.constInt(tag_ty_ref, tag_int);3407 return try self.constInt(tag_ty_ref, tag_int);
3406 }3408 }
34073409
3408 const un_active_ty_ref = try self.resolveUnionType(ty, active_field);3410 const tmp_id = try self.alloc(ty, .{ .storage_class = .Function });
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 });
34193411
3420 if (layout.tag_size != 0) {3412 if (layout.tag_size != 0) {
3421 const tag_ty_ref = try self.resolveType(maybe_tag_ty.?, .direct);3413 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);
3423 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});3415 const ptr_id = try self.accessChain(tag_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.tag_index))});
3424 const tag_id = try self.constInt(tag_ty_ref, tag_int);3416 const tag_id = try self.constInt(tag_ty_ref, tag_int);
3425 try self.func.body.emit(self.spv.gpa, .OpStore, .{3417 try self.store(maybe_tag_ty.?, ptr_id, tag_id, .{});
3426 .pointer = ptr_id,
3427 .object = tag_id,
3428 });
3429 }3418 }
34303419
3431 if (layout.active_field_size != 0) {3420 const payload_ty = union_ty.field_types.get(ip)[active_field].toType();
3432 const active_field_ty_ref = try self.resolveType(layout.active_field_ty, .indirect);3421 if (payload_ty.hasRuntimeBitsIgnoreComptime(mod)) {
3433 const active_field_ptr_ty_ref = try self.spv.ptrType(active_field_ty_ref, .Function);3422 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3434 const ptr_id = try self.accessChain(active_field_ptr_ty_ref, tmp_id, &.{@as(u32, @intCast(layout.active_field_index))});3423 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3435 try self.func.body.emit(self.spv.gpa, .OpStore, .{3424 const active_pl_ptr_ty_ref = try self.ptrType(payload_ty, .Function);
3436 .pointer = ptr_id,3425 const active_pl_ptr_id = self.spv.allocId();
3437 .object = payload.?,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,
3438 });3430 });
3431
3432 try self.store(payload_ty, active_pl_ptr_id, payload.?, .{});
3439 } else {3433 } else {
3440 assert(payload == null);3434 assert(payload == null);
3441 }3435 }
...@@ -3443,34 +3437,21 @@ const DeclGen = struct {...@@ -3443,34 +3437,21 @@ const DeclGen = struct {
3443 // Just leave the padding fields uninitialized...3437 // Just leave the padding fields uninitialized...
3444 // TODO: Or should we initialize them with undef explicitly?3438 // TODO: Or should we initialize them with undef explicitly?
34453439
3446 // Now cast the pointer and load it as the 'generic' union type.3440 return try self.load(ty, tmp_id, .{});
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;
3463 }3441 }
34643442
3465 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3443 fn airUnionInit(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
3466 if (self.liveness.isUnused(inst)) return null;3444 if (self.liveness.isUnused(inst)) return null;
34673445
3446 const mod = self.module;
3447 const ip = &mod.intern_pool;
3468 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;3448 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
3469 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;3449 const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
3470 const ty = self.typeOfIndex(inst);3450 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))
3474 try self.resolve(extra.init)3455 try self.resolve(extra.init)
3475 else3456 else
3476 null;3457 null;
...@@ -3499,30 +3480,24 @@ const DeclGen = struct {...@@ -3499,30 +3480,24 @@ const DeclGen = struct {
3499 .Union => switch (object_ty.containerLayout(mod)) {3480 .Union => switch (object_ty.containerLayout(mod)) {
3500 .Packed => unreachable, // TODO3481 .Packed => unreachable, // TODO
3501 else => {3482 else => {
3502 // Store, pointer-cast, load3483 // Store, ptr-elem-ptr, pointer-cast, load
3503 const un_general_ty_ref = try self.resolveType(object_ty, .indirect);3484 const layout = self.unionLayout(object_ty);
3504 const un_general_ptr_ty_ref = try self.spv.ptrType(un_general_ty_ref, .Function);3485 assert(layout.has_payload);
3505 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);3486
3506 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, .Function);3487 const tmp_id = try self.alloc(object_ty, .{ .storage_class = .Function });
3507 const field_ty_ref = try self.resolveType(field_ty, .indirect);3488 try self.store(object_ty, tmp_id, object_id, .{});
3508 const field_ptr_ty_ref = try self.spv.ptrType(field_ty_ref, .Function);3489
35093490 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, .Function);
3510 const tmp_id = self.spv.allocId();3491 const pl_ptr_id = try self.accessChain(pl_ptr_ty_ref, tmp_id, &.{layout.payload_index});
3511 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{3492
3512 .id_result_type = self.typeId(un_general_ptr_ty_ref),3493 const active_pl_ptr_ty_ref = try self.ptrType(field_ty, .Function);
3513 .id_result = tmp_id,3494 const active_pl_ptr_id = self.spv.allocId();
3514 .storage_class = .Function,
3515 });
3516 try self.store(object_ty, tmp_id, object_id, false);
3517 const casted_tmp_id = self.spv.allocId();
3518 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{3495 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3519 .id_result_type = self.typeId(un_active_ptr_ty_ref),3496 .id_result_type = self.typeId(active_pl_ptr_ty_ref),
3520 .id_result = casted_tmp_id,3497 .id_result = active_pl_ptr_id,
3521 .operand = tmp_id,3498 .operand = pl_ptr_id,
3522 });3499 });
3523 const layout = self.unionLayout(object_ty, field_index);3500 return try self.load(field_ty, active_pl_ptr_id, .{});
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);
3526 },3501 },
3527 },3502 },
3528 else => unreachable,3503 else => unreachable,
...@@ -3581,18 +3556,24 @@ const DeclGen = struct {...@@ -3581,18 +3556,24 @@ const DeclGen = struct {
3581 .Union => switch (object_ty.containerLayout(mod)) {3556 .Union => switch (object_ty.containerLayout(mod)) {
3582 .Packed => unreachable, // TODO3557 .Packed => unreachable, // TODO
3583 else => {3558 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
3584 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));3566 const storage_class = spvStorageClass(object_ptr_ty.ptrAddressSpace(mod));
3585 const un_active_ty_ref = try self.resolveUnionType(object_ty, field_index);3567 const pl_ptr_ty_ref = try self.ptrType(layout.payload_ty, storage_class);
3586 const un_active_ptr_ty_ref = try self.spv.ptrType(un_active_ty_ref, 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();
3589 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{3571 try self.func.body.emit(self.spv.gpa, .OpBitcast, .{
3590 .id_result_type = self.typeId(un_active_ptr_ty_ref),3572 .id_result_type = self.typeId(result_ty_ref),
3591 .id_result = casted_id,3573 .id_result = active_pl_ptr_id,
3592 .operand = object_ptr,3574 .operand = pl_ptr_id,
3593 });3575 });
3594 const layout = self.unionLayout(object_ty, field_index);3576 return active_pl_ptr_id;
3595 return try self.accessChain(result_ty_ref, casted_id, &.{layout.active_field_index});
3596 },3577 },
3597 },3578 },
3598 else => unreachable,3579 else => unreachable,
...@@ -3608,23 +3589,13 @@ const DeclGen = struct {...@@ -3608,23 +3589,13 @@ const DeclGen = struct {
3608 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);3589 return try self.structFieldPtr(result_ptr_ty, struct_ptr_ty, struct_ptr, field_index);
3609 }3590 }
36103591
3611 /// We cannot use an OpVariable directly in an OpSpecConstantOp, but we can3592 const AllocOptions = struct {
3612 /// after we insert a dummy AccessChain...3593 initializer: ?IdRef = null,
3613 /// TODO: Get rid of this3594 /// The final storage class of the pointer. This may be either `.Generic` or `.Function`.
3614 fn makePointerConstant(3595 /// In either case, the local is allocated in the `.Function` storage class, and optionally
3615 self: *DeclGen,3596 /// cast back to `.Generic`.
3616 section: *SpvSection,3597 storage_class: StorageClass = .Generic,
3617 ptr_ty_ref: CacheRef,3598 };
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 }
36283599
3629 // Allocate a function-local variable, with possible initializer.3600 // Allocate a function-local variable, with possible initializer.
3630 // This function returns a pointer to a variable of type `ty_ref`,3601 // This function returns a pointer to a variable of type `ty_ref`,
...@@ -3632,30 +3603,36 @@ const DeclGen = struct {...@@ -3632,30 +3603,36 @@ const DeclGen = struct {
3632 // placed in the Function address space.3603 // placed in the Function address space.
3633 fn alloc(3604 fn alloc(
3634 self: *DeclGen,3605 self: *DeclGen,
3635 ty_ref: CacheRef,3606 ty: Type,
3636 initializer: ?IdRef,3607 options: AllocOptions,
3637 ) !IdRef {3608 ) !IdRef {
3638 const fn_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Function);3609 const ptr_fn_ty_ref = try self.ptrType(ty, .Function);
3639 const general_ptr_ty_ref = try self.spv.ptrType(ty_ref, .Generic);
36403610
3641 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to3611 // SPIR-V requires that OpVariable declarations for locals go into the first block, so we are just going to
3642 // directly generate them into func.prologue instead of the body.3612 // directly generate them into func.prologue instead of the body.
3643 const var_id = self.spv.allocId();3613 const var_id = self.spv.allocId();
3644 try self.func.prologue.emit(self.spv.gpa, .OpVariable, .{3614 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),
3646 .id_result = var_id,3616 .id_result = var_id,
3647 .storage_class = .Function,3617 .storage_class = .Function,
3648 .initializer = initializer,3618 .initializer = options.initializer,
3649 });3619 });
36503620
3651 // Convert to a generic pointer3621 switch (options.storage_class) {
3652 const result_id = self.spv.allocId();3622 .Generic => {
3653 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{3623 const ptr_gn_ty_ref = try self.ptrType(ty, .Generic);
3654 .id_result_type = self.typeId(general_ptr_ty_ref),3624 // Convert to a generic pointer
3655 .id_result = result_id,3625 const result_id = self.spv.allocId();
3656 .pointer = var_id,3626 try self.func.body.emit(self.spv.gpa, .OpPtrCastToGeneric, .{
3657 });3627 .id_result_type = self.typeId(ptr_gn_ty_ref),
3658 return result_id;3628 .id_result = result_id,
3629 .pointer = var_id,
3630 });
3631 return result_id;
3632 },
3633 .Function => return var_id,
3634 else => unreachable,
3635 }
3659 }3636 }
36603637
3661 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3638 fn airAlloc(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -3664,8 +3641,7 @@ const DeclGen = struct {...@@ -3664,8 +3641,7 @@ const DeclGen = struct {
3664 const ptr_ty = self.typeOfIndex(inst);3641 const ptr_ty = self.typeOfIndex(inst);
3665 assert(ptr_ty.ptrAddressSpace(mod) == .generic);3642 assert(ptr_ty.ptrAddressSpace(mod) == .generic);
3666 const child_ty = ptr_ty.childType(mod);3643 const child_ty = ptr_ty.childType(mod);
3667 const child_ty_ref = try self.resolveType(child_ty, .indirect);3644 return try self.alloc(child_ty, .{});
3668 return try self.alloc(child_ty_ref, null);
3669 }3645 }
36703646
3671 fn airArg(self: *DeclGen) IdRef {3647 fn airArg(self: *DeclGen) IdRef {
...@@ -3780,7 +3756,7 @@ const DeclGen = struct {...@@ -3780,7 +3756,7 @@ const DeclGen = struct {
3780 const operand = try self.resolve(ty_op.operand);3756 const operand = try self.resolve(ty_op.operand);
3781 if (!ptr_ty.isVolatilePtr(mod) and self.liveness.isUnused(inst)) return null;3757 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) });
3784 }3760 }
37853761
3786 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {3762 fn airStore(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3790,7 +3766,7 @@ const DeclGen = struct {...@@ -3790,7 +3766,7 @@ const DeclGen = struct {
3790 const ptr = try self.resolve(bin_op.lhs);3766 const ptr = try self.resolve(bin_op.lhs);
3791 const value = try self.resolve(bin_op.rhs);3767 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) });
3794 }3770 }
37953771
3796 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {3772 fn airLoop(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -3854,7 +3830,7 @@ const DeclGen = struct {...@@ -3854,7 +3830,7 @@ const DeclGen = struct {
3854 }3830 }
38553831
3856 const ptr = try self.resolve(un_op);3832 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) });
3858 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{3834 try self.func.body.emit(self.spv.gpa, .OpReturnValue, .{
3859 .value = value,3835 .value = value,
3860 });3836 });
...@@ -3980,8 +3956,11 @@ const DeclGen = struct {...@@ -3980,8 +3956,11 @@ const DeclGen = struct {
3980 members[eu_layout.errorFieldIndex()] = operand_id;3956 members[eu_layout.errorFieldIndex()] = operand_id;
3981 members[eu_layout.payloadFieldIndex()] = try self.spv.constUndef(payload_ty_ref);3957 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);3959 var types: [2]Type = undefined;
3984 return try self.constructStruct(err_union_ty_ref, &members);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);
3985 }3964 }
39863965
3987 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {3966 fn airWrapErrUnionPayload(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {
...@@ -4002,8 +3981,11 @@ const DeclGen = struct {...@@ -4002,8 +3981,11 @@ const DeclGen = struct {
4002 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);3981 members[eu_layout.errorFieldIndex()] = try self.constInt(err_ty_ref, 0);
4003 members[eu_layout.payloadFieldIndex()] = try self.convertToIndirect(payload_ty, operand_id);3982 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);3984 var types: [2]Type = undefined;
4006 return try self.constructStruct(err_union_ty_ref, &members);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);
4007 }3989 }
40083990
4009 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {3991 fn airIsNull(self: *DeclGen, inst: Air.Inst.Index, pred: enum { is_null, is_non_null }) !?IdRef {
...@@ -4037,7 +4019,7 @@ const DeclGen = struct {...@@ -4037,7 +4019,7 @@ const DeclGen = struct {
4037 .is_null => .eq,4019 .is_null => .eq,
4038 .is_non_null => .neq,4020 .is_non_null => .neq,
4039 };4021 };
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);
4041 }4023 }
40424024
4043 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))4025 const is_non_null_id = if (payload_ty.hasRuntimeBitsIgnoreComptime(mod))
...@@ -4135,10 +4117,10 @@ const DeclGen = struct {...@@ -4135,10 +4117,10 @@ const DeclGen = struct {
4135 return operand_id;4117 return operand_id;
4136 }4118 }
41374119
4138 const optional_ty_ref = try self.resolveType(optional_ty, .direct);
4139 const payload_id = try self.convertToIndirect(payload_ty, operand_id);4120 const payload_id = try self.convertToIndirect(payload_ty, operand_id);
4140 const members = [_]IdRef{ payload_id, try self.constBool(true, .indirect) };4121 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);
4142 }4124 }
41434125
4144 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {4126 fn airSwitchBr(self: *DeclGen, inst: Air.Inst.Index) !void {
...@@ -4420,6 +4402,7 @@ const DeclGen = struct {...@@ -4420,6 +4402,7 @@ const DeclGen = struct {
4420 }4402 }
44214403
4422 // TODO: Multiple results4404 // TODO: Multiple results
4405 // TODO: Check that the output type from assembly is the same as the type actually expected by Zig.
4423 }4406 }
44244407
4425 return null;4408 return null;
src/codegen/spirv/Assembler.zig+10-4
...@@ -304,10 +304,16 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {...@@ -304,10 +304,16 @@ fn processTypeInstruction(self: *Assembler) !AsmValue {
304 // and so some consideration must be taken when entering this in the type system.304 // and so some consideration must be taken when entering this in the type system.
305 return self.todo("process OpTypeArray", .{});305 return self.todo("process OpTypeArray", .{});
306 },306 },
307 .OpTypePointer => try self.spv.ptrType(307 .OpTypePointer => blk: {
308 try self.resolveTypeRef(operands[2].ref_id),308 break :blk try self.spv.resolve(.{
309 @as(spec.StorageClass, @enumFromInt(operands[1].value)),309 .ptr_type = .{
310 ),310 .storage_class = @enumFromInt(operands[1].value),
311 .child_type = try self.resolveTypeRef(operands[2].ref_id),
312 // TODO: This should be a proper reference resolved via OpTypeForwardPointer
313 .fwd = @enumFromInt(std.math.maxInt(u32)),
314 },
315 });
316 },
311 .OpTypeFunction => blk: {317 .OpTypeFunction => blk: {
312 const param_operands = operands[2..];318 const param_operands = operands[2..];
313 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);319 const param_types = try self.spv.gpa.alloc(CacheRef, param_operands.len);
src/codegen/spirv/Cache.zig+182-124
...@@ -22,6 +22,8 @@ const Opcode = spec.Opcode;...@@ -22,6 +22,8 @@ const Opcode = spec.Opcode;
22const IdResult = spec.IdResult;22const IdResult = spec.IdResult;
23const StorageClass = spec.StorageClass;23const StorageClass = spec.StorageClass;
2424
25const InternPool = @import("../../InternPool.zig");
26
25const Self = @This();27const Self = @This();
2628
27map: std.AutoArrayHashMapUnmanaged(void, void) = .{},29map: std.AutoArrayHashMapUnmanaged(void, void) = .{},
...@@ -31,6 +33,8 @@ extra: std.ArrayListUnmanaged(u32) = .{},...@@ -31,6 +33,8 @@ extra: std.ArrayListUnmanaged(u32) = .{},
31string_bytes: std.ArrayListUnmanaged(u8) = .{},33string_bytes: std.ArrayListUnmanaged(u8) = .{},
32strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},34strings: std.AutoArrayHashMapUnmanaged(void, u32) = .{},
3335
36recursive_ptrs: std.AutoHashMapUnmanaged(Ref, void) = .{},
37
34const Item = struct {38const Item = struct {
35 tag: Tag,39 tag: Tag,
36 /// The result-id that this item uses.40 /// The result-id that this item uses.
...@@ -62,18 +66,21 @@ const Tag = enum {...@@ -62,18 +66,21 @@ const Tag = enum {
62 /// Function (proto)type66 /// Function (proto)type
63 /// data is payload to FunctionType67 /// data is payload to FunctionType
64 type_function,68 type_function,
65 /// Pointer type in the CrossWorkgroup storage class69 // /// Pointer type in the CrossWorkgroup storage class
66 /// data is child type70 // /// data is child type
67 type_ptr_generic,71 // type_ptr_generic,
68 /// Pointer type in the CrossWorkgroup storage class72 // /// Pointer type in the CrossWorkgroup storage class
69 /// data is child type73 // /// data is child type
70 type_ptr_crosswgp,74 // type_ptr_crosswgp,
71 /// Pointer type in the Function storage class75 // /// Pointer type in the Function storage class
72 /// data is child type76 // /// data is child type
73 type_ptr_function,77 // type_ptr_function,
74 /// Simple pointer type that does not have any decorations.78 /// Simple pointer type that does not have any decorations.
75 /// data is payload to SimplePointerType79 /// data is payload to SimplePointerType
76 type_ptr_simple,80 type_ptr_simple,
81 /// A forward declaration for a pointer.
82 /// data is ForwardPointerType
83 type_fwd_ptr,
77 /// Simple structure type that does not have any decorations.84 /// Simple structure type that does not have any decorations.
78 /// data is payload to SimpleStructType85 /// data is payload to SimpleStructType
79 type_struct_simple,86 type_struct_simple,
...@@ -142,6 +149,12 @@ const Tag = enum {...@@ -142,6 +149,12 @@ const Tag = enum {
142 const SimplePointerType = struct {149 const SimplePointerType = struct {
143 storage_class: StorageClass,150 storage_class: StorageClass,
144 child_type: Ref,151 child_type: Ref,
152 fwd: Ref,
153 };
154
155 const ForwardPointerType = struct {
156 storage_class: StorageClass,
157 zig_child_type: InternPool.Index,
145 };158 };
146159
147 /// Trailing:160 /// Trailing:
...@@ -163,14 +176,14 @@ const Tag = enum {...@@ -163,14 +176,14 @@ const Tag = enum {
163 fn encode(value: f64) Float64 {176 fn encode(value: f64) Float64 {
164 const bits = @as(u64, @bitCast(value));177 const bits = @as(u64, @bitCast(value));
165 return .{178 return .{
166 .low = @as(u32, @truncate(bits)),179 .low = @truncate(bits),
167 .high = @as(u32, @truncate(bits >> 32)),180 .high = @truncate(bits >> 32),
168 };181 };
169 }182 }
170183
171 fn decode(self: Float64) f64 {184 fn decode(self: Float64) f64 {
172 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);185 const bits = @as(u64, self.low) | (@as(u64, self.high) << 32);
173 return @as(f64, @bitCast(bits));186 return @bitCast(bits);
174 }187 }
175 };188 };
176189
...@@ -192,8 +205,8 @@ const Tag = enum {...@@ -192,8 +205,8 @@ const Tag = enum {
192 fn encode(ty: Ref, value: u64) Int64 {205 fn encode(ty: Ref, value: u64) Int64 {
193 return .{206 return .{
194 .ty = ty,207 .ty = ty,
195 .low = @as(u32, @truncate(value)),208 .low = @truncate(value),
196 .high = @as(u32, @truncate(value >> 32)),209 .high = @truncate(value >> 32),
197 };210 };
198 }211 }
199212
...@@ -210,8 +223,8 @@ const Tag = enum {...@@ -210,8 +223,8 @@ const Tag = enum {
210 fn encode(ty: Ref, value: i64) Int64 {223 fn encode(ty: Ref, value: i64) Int64 {
211 return .{224 return .{
212 .ty = ty,225 .ty = ty,
213 .low = @as(u32, @truncate(@as(u64, @bitCast(value)))),226 .low = @truncate(@as(u64, @bitCast(value))),
214 .high = @as(u32, @truncate(@as(u64, @bitCast(value)) >> 32)),227 .high = @truncate(@as(u64, @bitCast(value)) >> 32),
215 };228 };
216 }229 }
217230
...@@ -237,6 +250,7 @@ pub const Key = union(enum) {...@@ -237,6 +250,7 @@ pub const Key = union(enum) {
237 array_type: ArrayType,250 array_type: ArrayType,
238 function_type: FunctionType,251 function_type: FunctionType,
239 ptr_type: PointerType,252 ptr_type: PointerType,
253 fwd_ptr_type: ForwardPointerType,
240 struct_type: StructType,254 struct_type: StructType,
241 opaque_type: OpaqueType,255 opaque_type: OpaqueType,
242256
...@@ -273,12 +287,18 @@ pub const Key = union(enum) {...@@ -273,12 +287,18 @@ pub const Key = union(enum) {
273 pub const PointerType = struct {287 pub const PointerType = struct {
274 storage_class: StorageClass,288 storage_class: StorageClass,
275 child_type: Ref,289 child_type: Ref,
290 fwd: Ref,
276 // TODO: Decorations:291 // TODO: Decorations:
277 // - Alignment292 // - Alignment
278 // - ArrayStride,293 // - ArrayStride,
279 // - MaxByteOffset,294 // - MaxByteOffset,
280 };295 };
281296
297 pub const ForwardPointerType = struct {
298 zig_child_type: InternPool.Index,
299 storage_class: StorageClass,
300 };
301
282 pub const StructType = struct {302 pub const StructType = struct {
283 // TODO: Decorations.303 // TODO: Decorations.
284 /// The name of the structure. Can be `.none`.304 /// The name of the structure. Can be `.none`.
...@@ -313,21 +333,21 @@ pub const Key = union(enum) {...@@ -313,21 +333,21 @@ pub const Key = union(enum) {
313 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.333 /// Turns this value into the corresponding 32-bit literal, 2s complement signed.
314 fn toBits32(self: Int) u32 {334 fn toBits32(self: Int) u32 {
315 return switch (self.value) {335 return switch (self.value) {
316 .uint64 => |val| @as(u32, @intCast(val)),336 .uint64 => |val| @intCast(val),
317 .int64 => |val| if (val < 0) @as(u32, @bitCast(@as(i32, @intCast(val)))) else @as(u32, @intCast(val)),337 .int64 => |val| if (val < 0) @bitCast(@as(i32, @intCast(val))) else @intCast(val),
318 };338 };
319 }339 }
320340
321 fn toBits64(self: Int) u64 {341 fn toBits64(self: Int) u64 {
322 return switch (self.value) {342 return switch (self.value) {
323 .uint64 => |val| val,343 .uint64 => |val| val,
324 .int64 => |val| @as(u64, @bitCast(val)),344 .int64 => |val| @bitCast(val),
325 };345 };
326 }346 }
327347
328 fn to(self: Int, comptime T: type) T {348 fn to(self: Int, comptime T: type) T {
329 return switch (self.value) {349 return switch (self.value) {
330 inline else => |val| @as(T, @intCast(val)),350 inline else => |val| @intCast(val),
331 };351 };
332 }352 }
333 };353 };
...@@ -387,7 +407,7 @@ pub const Key = union(enum) {...@@ -387,7 +407,7 @@ pub const Key = union(enum) {
387 },407 },
388 inline else => |key| std.hash.autoHash(&hasher, key),408 inline else => |key| std.hash.autoHash(&hasher, key),
389 }409 }
390 return @as(u32, @truncate(hasher.final()));410 return @truncate(hasher.final());
391 }411 }
392412
393 fn eql(a: Key, b: Key) bool {413 fn eql(a: Key, b: Key) bool {
...@@ -419,7 +439,7 @@ pub const Key = union(enum) {...@@ -419,7 +439,7 @@ pub const Key = union(enum) {
419439
420 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {440 pub fn eql(ctx: @This(), a: Key, b_void: void, b_index: usize) bool {
421 _ = b_void;441 _ = b_void;
422 return ctx.self.lookup(@as(Ref, @enumFromInt(b_index))).eql(a);442 return ctx.self.lookup(@enumFromInt(b_index)).eql(a);
423 }443 }
424444
425 pub fn hash(ctx: @This(), a: Key) u32 {445 pub fn hash(ctx: @This(), a: Key) u32 {
...@@ -450,6 +470,7 @@ pub fn deinit(self: *Self, spv: *const Module) void {...@@ -450,6 +470,7 @@ pub fn deinit(self: *Self, spv: *const Module) void {
450 self.extra.deinit(spv.gpa);470 self.extra.deinit(spv.gpa);
451 self.string_bytes.deinit(spv.gpa);471 self.string_bytes.deinit(spv.gpa);
452 self.strings.deinit(spv.gpa);472 self.strings.deinit(spv.gpa);
473 self.recursive_ptrs.deinit(spv.gpa);
453}474}
454475
455/// Actually materialize the database into spir-v instructions.476/// Actually materialize the database into spir-v instructions.
...@@ -460,7 +481,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {...@@ -460,7 +481,7 @@ pub fn materialize(self: *const Self, spv: *Module) !Section {
460 var section = Section{};481 var section = Section{};
461 errdefer section.deinit(spv.gpa);482 errdefer section.deinit(spv.gpa);
462 for (self.items.items(.result_id), 0..) |result_id, index| {483 for (self.items.items(.result_id), 0..) |result_id, index| {
463 try self.emit(spv, result_id, @as(Ref, @enumFromInt(index)), &section);484 try self.emit(spv, result_id, @enumFromInt(index), &section);
464 }485 }
465 return section;486 return section;
466}487}
...@@ -538,6 +559,15 @@ fn emit(...@@ -538,6 +559,15 @@ fn emit(
538 });559 });
539 // TODO: Decorations?560 // TODO: Decorations?
540 },561 },
562 .fwd_ptr_type => |fwd| {
563 // Only emit the OpTypeForwardPointer if its actually required.
564 if (self.recursive_ptrs.contains(ref)) {
565 try section.emit(spv.gpa, .OpTypeForwardPointer, .{
566 .pointer_type = result_id,
567 .storage_class = fwd.storage_class,
568 });
569 }
570 },
541 .struct_type => |struct_type| {571 .struct_type => |struct_type| {
542 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);572 try section.emitRaw(spv.gpa, .OpTypeStruct, 1 + struct_type.member_types.len);
543 section.writeOperand(IdResult, result_id);573 section.writeOperand(IdResult, result_id);
...@@ -549,7 +579,7 @@ fn emit(...@@ -549,7 +579,7 @@ fn emit(
549 }579 }
550 for (struct_type.memberNames(), 0..) |member_name, i| {580 for (struct_type.memberNames(), 0..) |member_name, i| {
551 if (self.getString(member_name)) |name| {581 if (self.getString(member_name)) |name| {
552 try spv.memberDebugName(result_id, @as(u32, @intCast(i)), name);582 try spv.memberDebugName(result_id, @intCast(i), name);
553 }583 }
554 }584 }
555 // TODO: Decorations?585 // TODO: Decorations?
...@@ -625,13 +655,12 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -625,13 +655,12 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
625 const adapter: Key.Adapter = .{ .self = self };655 const adapter: Key.Adapter = .{ .self = self };
626 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);656 const entry = try self.map.getOrPutAdapted(spv.gpa, key, adapter);
627 if (entry.found_existing) {657 if (entry.found_existing) {
628 return @as(Ref, @enumFromInt(entry.index));658 return @enumFromInt(entry.index);
629 }659 }
630 const result_id = spv.allocId();
631 const item: Item = switch (key) {660 const item: Item = switch (key) {
632 inline .void_type, .bool_type => .{661 inline .void_type, .bool_type => .{
633 .tag = .type_simple,662 .tag = .type_simple,
634 .result_id = result_id,663 .result_id = spv.allocId(),
635 .data = @intFromEnum(key.toSimpleType()),664 .data = @intFromEnum(key.toSimpleType()),
636 },665 },
637 .int_type => |int| blk: {666 .int_type => |int| blk: {
...@@ -641,87 +670,104 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -641,87 +670,104 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
641 };670 };
642 break :blk .{671 break :blk .{
643 .tag = t,672 .tag = t,
644 .result_id = result_id,673 .result_id = spv.allocId(),
645 .data = int.bits,674 .data = int.bits,
646 };675 };
647 },676 },
648 .float_type => |float| .{677 .float_type => |float| .{
649 .tag = .type_float,678 .tag = .type_float,
650 .result_id = result_id,679 .result_id = spv.allocId(),
651 .data = float.bits,680 .data = float.bits,
652 },681 },
653 .vector_type => |vector| .{682 .vector_type => |vector| .{
654 .tag = .type_vector,683 .tag = .type_vector,
655 .result_id = result_id,684 .result_id = spv.allocId(),
656 .data = try self.addExtra(spv, vector),685 .data = try self.addExtra(spv, vector),
657 },686 },
658 .array_type => |array| .{687 .array_type => |array| .{
659 .tag = .type_array,688 .tag = .type_array,
660 .result_id = result_id,689 .result_id = spv.allocId(),
661 .data = try self.addExtra(spv, array),690 .data = try self.addExtra(spv, array),
662 },691 },
663 .function_type => |function| blk: {692 .function_type => |function| blk: {
664 const extra = try self.addExtra(spv, Tag.FunctionType{693 const extra = try self.addExtra(spv, Tag.FunctionType{
665 .param_len = @as(u32, @intCast(function.parameters.len)),694 .param_len = @intCast(function.parameters.len),
666 .return_type = function.return_type,695 .return_type = function.return_type,
667 });696 });
668 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(function.parameters)));697 try self.extra.appendSlice(spv.gpa, @ptrCast(function.parameters));
669 break :blk .{698 break :blk .{
670 .tag = .type_function,699 .tag = .type_function,
671 .result_id = result_id,700 .result_id = spv.allocId(),
672 .data = extra,701 .data = extra,
673 };702 };
674 },703 },
675 .ptr_type => |ptr| switch (ptr.storage_class) {704 // .ptr_type => |ptr| switch (ptr.storage_class) {
676 .Generic => Item{705 // .Generic => Item{
677 .tag = .type_ptr_generic,706 // .tag = .type_ptr_generic,
678 .result_id = result_id,707 // .result_id = spv.allocId(),
679 .data = @intFromEnum(ptr.child_type),708 // .data = @intFromEnum(ptr.child_type),
680 },709 // },
681 .CrossWorkgroup => Item{710 // .CrossWorkgroup => Item{
682 .tag = .type_ptr_crosswgp,711 // .tag = .type_ptr_crosswgp,
683 .result_id = result_id,712 // .result_id = spv.allocId(),
684 .data = @intFromEnum(ptr.child_type),713 // .data = @intFromEnum(ptr.child_type),
685 },714 // },
686 .Function => Item{715 // .Function => Item{
687 .tag = .type_ptr_function,716 // .tag = .type_ptr_function,
688 .result_id = result_id,717 // .result_id = spv.allocId(),
689 .data = @intFromEnum(ptr.child_type),718 // .data = @intFromEnum(ptr.child_type),
690 },719 // },
691 else => |storage_class| Item{720 // else => |storage_class| Item{
692 .tag = .type_ptr_simple,721 // .tag = .type_ptr_simple,
693 .result_id = result_id,722 // .result_id = spv.allocId(),
694 .data = try self.addExtra(spv, Tag.SimplePointerType{723 // .data = try self.addExtra(spv, Tag.SimplePointerType{
695 .storage_class = storage_class,724 // .storage_class = storage_class,
696 .child_type = ptr.child_type,725 // .child_type = ptr.child_type,
697 }),726 // }),
698 },727 // },
728 // },
729 .ptr_type => |ptr| Item{
730 .tag = .type_ptr_simple,
731 .result_id = self.resultId(ptr.fwd),
732 .data = try self.addExtra(spv, Tag.SimplePointerType{
733 .storage_class = ptr.storage_class,
734 .child_type = ptr.child_type,
735 .fwd = ptr.fwd,
736 }),
737 },
738 .fwd_ptr_type => |fwd| Item{
739 .tag = .type_fwd_ptr,
740 .result_id = spv.allocId(),
741 .data = try self.addExtra(spv, Tag.ForwardPointerType{
742 .zig_child_type = fwd.zig_child_type,
743 .storage_class = fwd.storage_class,
744 }),
699 },745 },
700 .struct_type => |struct_type| blk: {746 .struct_type => |struct_type| blk: {
701 const extra = try self.addExtra(spv, Tag.SimpleStructType{747 const extra = try self.addExtra(spv, Tag.SimpleStructType{
702 .name = struct_type.name,748 .name = struct_type.name,
703 .members_len = @as(u32, @intCast(struct_type.member_types.len)),749 .members_len = @intCast(struct_type.member_types.len),
704 });750 });
705 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(struct_type.member_types)));751 try self.extra.appendSlice(spv.gpa, @ptrCast(struct_type.member_types));
706752
707 if (struct_type.member_names) |member_names| {753 if (struct_type.member_names) |member_names| {
708 try self.extra.appendSlice(spv.gpa, @as([]const u32, @ptrCast(member_names)));754 try self.extra.appendSlice(spv.gpa, @ptrCast(member_names));
709 break :blk Item{755 break :blk Item{
710 .tag = .type_struct_simple_with_member_names,756 .tag = .type_struct_simple_with_member_names,
711 .result_id = result_id,757 .result_id = spv.allocId(),
712 .data = extra,758 .data = extra,
713 };759 };
714 } else {760 } else {
715 break :blk Item{761 break :blk Item{
716 .tag = .type_struct_simple,762 .tag = .type_struct_simple,
717 .result_id = result_id,763 .result_id = spv.allocId(),
718 .data = extra,764 .data = extra,
719 };765 };
720 }766 }
721 },767 },
722 .opaque_type => |opaque_type| Item{768 .opaque_type => |opaque_type| Item{
723 .tag = .type_opaque,769 .tag = .type_opaque,
724 .result_id = result_id,770 .result_id = spv.allocId(),
725 .data = @intFromEnum(opaque_type.name),771 .data = @intFromEnum(opaque_type.name),
726 },772 },
727 .int => |int| blk: {773 .int => |int| blk: {
...@@ -729,13 +775,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -729,13 +775,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
729 if (int_type.signedness == .unsigned and int_type.bits == 8) {775 if (int_type.signedness == .unsigned and int_type.bits == 8) {
730 break :blk .{776 break :blk .{
731 .tag = .uint8,777 .tag = .uint8,
732 .result_id = result_id,778 .result_id = spv.allocId(),
733 .data = int.to(u8),779 .data = int.to(u8),
734 };780 };
735 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {781 } else if (int_type.signedness == .unsigned and int_type.bits == 32) {
736 break :blk .{782 break :blk .{
737 .tag = .uint32,783 .tag = .uint32,
738 .result_id = result_id,784 .result_id = spv.allocId(),
739 .data = int.to(u32),785 .data = int.to(u32),
740 };786 };
741 }787 }
...@@ -745,32 +791,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -745,32 +791,32 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
745 if (val >= 0 and val <= std.math.maxInt(u32)) {791 if (val >= 0 and val <= std.math.maxInt(u32)) {
746 break :blk .{792 break :blk .{
747 .tag = .uint_small,793 .tag = .uint_small,
748 .result_id = result_id,794 .result_id = spv.allocId(),
749 .data = try self.addExtra(spv, Tag.UInt32{795 .data = try self.addExtra(spv, Tag.UInt32{
750 .ty = int.ty,796 .ty = int.ty,
751 .value = @as(u32, @intCast(val)),797 .value = @intCast(val),
752 }),798 }),
753 };799 };
754 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {800 } else if (val >= std.math.minInt(i32) and val <= std.math.maxInt(i32)) {
755 break :blk .{801 break :blk .{
756 .tag = .int_small,802 .tag = .int_small,
757 .result_id = result_id,803 .result_id = spv.allocId(),
758 .data = try self.addExtra(spv, Tag.Int32{804 .data = try self.addExtra(spv, Tag.Int32{
759 .ty = int.ty,805 .ty = int.ty,
760 .value = @as(i32, @intCast(val)),806 .value = @intCast(val),
761 }),807 }),
762 };808 };
763 } else if (val < 0) {809 } else if (val < 0) {
764 break :blk .{810 break :blk .{
765 .tag = .int_large,811 .tag = .int_large,
766 .result_id = result_id,812 .result_id = spv.allocId(),
767 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @as(i64, @intCast(val)))),813 .data = try self.addExtra(spv, Tag.Int64.encode(int.ty, @intCast(val))),
768 };814 };
769 } else {815 } else {
770 break :blk .{816 break :blk .{
771 .tag = .uint_large,817 .tag = .uint_large,
772 .result_id = result_id,818 .result_id = spv.allocId(),
773 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @as(u64, @intCast(val)))),819 .data = try self.addExtra(spv, Tag.UInt64.encode(int.ty, @intCast(val))),
774 };820 };
775 }821 }
776 },822 },
...@@ -779,29 +825,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -779,29 +825,29 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
779 .float => |float| switch (self.lookup(float.ty).float_type.bits) {825 .float => |float| switch (self.lookup(float.ty).float_type.bits) {
780 16 => .{826 16 => .{
781 .tag = .float16,827 .tag = .float16,
782 .result_id = result_id,828 .result_id = spv.allocId(),
783 .data = @as(u16, @bitCast(float.value.float16)),829 .data = @as(u16, @bitCast(float.value.float16)),
784 },830 },
785 32 => .{831 32 => .{
786 .tag = .float32,832 .tag = .float32,
787 .result_id = result_id,833 .result_id = spv.allocId(),
788 .data = @as(u32, @bitCast(float.value.float32)),834 .data = @as(u32, @bitCast(float.value.float32)),
789 },835 },
790 64 => .{836 64 => .{
791 .tag = .float64,837 .tag = .float64,
792 .result_id = result_id,838 .result_id = spv.allocId(),
793 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),839 .data = try self.addExtra(spv, Tag.Float64.encode(float.value.float64)),
794 },840 },
795 else => unreachable,841 else => unreachable,
796 },842 },
797 .undef => |undef| .{843 .undef => |undef| .{
798 .tag = .undef,844 .tag = .undef,
799 .result_id = result_id,845 .result_id = spv.allocId(),
800 .data = @intFromEnum(undef.ty),846 .data = @intFromEnum(undef.ty),
801 },847 },
802 .null => |null_info| .{848 .null => |null_info| .{
803 .tag = .null,849 .tag = .null,
804 .result_id = result_id,850 .result_id = spv.allocId(),
805 .data = @intFromEnum(null_info.ty),851 .data = @intFromEnum(null_info.ty),
806 },852 },
807 .bool => |bool_info| .{853 .bool => |bool_info| .{
...@@ -809,13 +855,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {...@@ -809,13 +855,13 @@ pub fn resolve(self: *Self, spv: *Module, key: Key) !Ref {
809 true => Tag.bool_true,855 true => Tag.bool_true,
810 false => Tag.bool_false,856 false => Tag.bool_false,
811 },857 },
812 .result_id = result_id,858 .result_id = spv.allocId(),
813 .data = @intFromEnum(bool_info.ty),859 .data = @intFromEnum(bool_info.ty),
814 },860 },
815 };861 };
816 try self.items.append(spv.gpa, item);862 try self.items.append(spv.gpa, item);
817863
818 return @as(Ref, @enumFromInt(entry.index));864 return @enumFromInt(entry.index);
819}865}
820866
821/// Turn a Ref back into a Key.867/// Turn a Ref back into a Key.
...@@ -830,14 +876,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -830,14 +876,14 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
830 },876 },
831 .type_int_signed => .{ .int_type = .{877 .type_int_signed => .{ .int_type = .{
832 .signedness = .signed,878 .signedness = .signed,
833 .bits = @as(u16, @intCast(data)),879 .bits = @intCast(data),
834 } },880 } },
835 .type_int_unsigned => .{ .int_type = .{881 .type_int_unsigned => .{ .int_type = .{
836 .signedness = .unsigned,882 .signedness = .unsigned,
837 .bits = @as(u16, @intCast(data)),883 .bits = @intCast(data),
838 } },884 } },
839 .type_float => .{ .float_type = .{885 .type_float => .{ .float_type = .{
840 .bits = @as(u16, @intCast(data)),886 .bits = @intCast(data),
841 } },887 } },
842 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },888 .type_vector => .{ .vector_type = self.extraData(Tag.VectorType, data) },
843 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },889 .type_array => .{ .array_type = self.extraData(Tag.ArrayType, data) },
...@@ -846,40 +892,50 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -846,40 +892,50 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
846 return .{892 return .{
847 .function_type = .{893 .function_type = .{
848 .return_type = payload.data.return_type,894 .return_type = payload.data.return_type,
849 .parameters = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len])),895 .parameters = @ptrCast(self.extra.items[payload.trail..][0..payload.data.param_len]),
850 },896 },
851 };897 };
852 },898 },
853 .type_ptr_generic => .{899 // .type_ptr_generic => .{
854 .ptr_type = .{900 // .ptr_type = .{
855 .storage_class = .Generic,901 // .storage_class = .Generic,
856 .child_type = @as(Ref, @enumFromInt(data)),902 // .child_type = @enumFromInt(data),
857 },903 // },
858 },904 // },
859 .type_ptr_crosswgp => .{905 // .type_ptr_crosswgp => .{
860 .ptr_type = .{906 // .ptr_type = .{
861 .storage_class = .CrossWorkgroup,907 // .storage_class = .CrossWorkgroup,
862 .child_type = @as(Ref, @enumFromInt(data)),908 // .child_type = @enumFromInt(data),
863 },909 // },
864 },910 // },
865 .type_ptr_function => .{911 // .type_ptr_function => .{
866 .ptr_type = .{912 // .ptr_type = .{
867 .storage_class = .Function,913 // .storage_class = .Function,
868 .child_type = @as(Ref, @enumFromInt(data)),914 // .child_type = @enumFromInt(data),
869 },915 // },
870 },916 // },
871 .type_ptr_simple => {917 .type_ptr_simple => {
872 const payload = self.extraData(Tag.SimplePointerType, data);918 const payload = self.extraData(Tag.SimplePointerType, data);
873 return .{919 return .{
874 .ptr_type = .{920 .ptr_type = .{
875 .storage_class = payload.storage_class,921 .storage_class = payload.storage_class,
876 .child_type = payload.child_type,922 .child_type = payload.child_type,
923 .fwd = payload.fwd,
924 },
925 };
926 },
927 .type_fwd_ptr => {
928 const payload = self.extraData(Tag.ForwardPointerType, data);
929 return .{
930 .fwd_ptr_type = .{
931 .zig_child_type = payload.zig_child_type,
932 .storage_class = payload.storage_class,
877 },933 },
878 };934 };
879 },935 },
880 .type_struct_simple => {936 .type_struct_simple => {
881 const payload = self.extraDataTrail(Tag.SimpleStructType, data);937 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
882 const member_types = @as([]const Ref, @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]));938 const member_types: []const Ref = @ptrCast(self.extra.items[payload.trail..][0..payload.data.members_len]);
883 return .{939 return .{
884 .struct_type = .{940 .struct_type = .{
885 .name = payload.data.name,941 .name = payload.data.name,
...@@ -891,8 +947,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -891,8 +947,8 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
891 .type_struct_simple_with_member_names => {947 .type_struct_simple_with_member_names => {
892 const payload = self.extraDataTrail(Tag.SimpleStructType, data);948 const payload = self.extraDataTrail(Tag.SimpleStructType, data);
893 const trailing = self.extra.items[payload.trail..];949 const trailing = self.extra.items[payload.trail..];
894 const member_types = @as([]const Ref, @ptrCast(trailing[0..payload.data.members_len]));950 const member_types: []const Ref = @ptrCast(trailing[0..payload.data.members_len]);
895 const member_names = @as([]const String, @ptrCast(trailing[payload.data.members_len..][0..payload.data.members_len]));951 const member_names: []const String = @ptrCast(trailing[payload.data.members_len..][0..payload.data.members_len]);
896 return .{952 return .{
897 .struct_type = .{953 .struct_type = .{
898 .name = payload.data.name,954 .name = payload.data.name,
...@@ -903,16 +959,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -903,16 +959,16 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
903 },959 },
904 .type_opaque => .{960 .type_opaque => .{
905 .opaque_type = .{961 .opaque_type = .{
906 .name = @as(String, @enumFromInt(data)),962 .name = @enumFromInt(data),
907 },963 },
908 },964 },
909 .float16 => .{ .float = .{965 .float16 => .{ .float = .{
910 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),966 .ty = self.get(.{ .float_type = .{ .bits = 16 } }),
911 .value = .{ .float16 = @as(f16, @bitCast(@as(u16, @intCast(data)))) },967 .value = .{ .float16 = @bitCast(@as(u16, @intCast(data))) },
912 } },968 } },
913 .float32 => .{ .float = .{969 .float32 => .{ .float = .{
914 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),970 .ty = self.get(.{ .float_type = .{ .bits = 32 } }),
915 .value = .{ .float32 = @as(f32, @bitCast(data)) },971 .value = .{ .float32 = @bitCast(data) },
916 } },972 } },
917 .float64 => .{ .float = .{973 .float64 => .{ .float = .{
918 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),974 .ty = self.get(.{ .float_type = .{ .bits = 64 } }),
...@@ -955,17 +1011,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {...@@ -955,17 +1011,17 @@ pub fn lookup(self: *const Self, ref: Ref) Key {
955 } };1011 } };
956 },1012 },
957 .undef => .{ .undef = .{1013 .undef => .{ .undef = .{
958 .ty = @as(Ref, @enumFromInt(data)),1014 .ty = @enumFromInt(data),
959 } },1015 } },
960 .null => .{ .null = .{1016 .null => .{ .null = .{
961 .ty = @as(Ref, @enumFromInt(data)),1017 .ty = @enumFromInt(data),
962 } },1018 } },
963 .bool_true => .{ .bool = .{1019 .bool_true => .{ .bool = .{
964 .ty = @as(Ref, @enumFromInt(data)),1020 .ty = @enumFromInt(data),
965 .value = true,1021 .value = true,
966 } },1022 } },
967 .bool_false => .{ .bool = .{1023 .bool_false => .{ .bool = .{
968 .ty = @as(Ref, @enumFromInt(data)),1024 .ty = @enumFromInt(data),
969 .value = false,1025 .value = false,
970 } },1026 } },
971 };1027 };
...@@ -981,7 +1037,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {...@@ -981,7 +1037,7 @@ pub fn resultId(self: Self, ref: Ref) IdResult {
981fn get(self: *const Self, key: Key) Ref {1037fn get(self: *const Self, key: Key) Ref {
982 const adapter: Key.Adapter = .{ .self = self };1038 const adapter: Key.Adapter = .{ .self = self };
983 const index = self.map.getIndexAdapted(key, adapter).?;1039 const index = self.map.getIndexAdapted(key, adapter).?;
984 return @as(Ref, @enumFromInt(index));1040 return @enumFromInt(index);
985}1041}
9861042
987fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {1043fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
...@@ -991,15 +1047,16 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {...@@ -991,15 +1047,16 @@ fn addExtra(self: *Self, spv: *Module, extra: anytype) !u32 {
991}1047}
9921048
993fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {1049fn addExtraAssumeCapacity(self: *Self, extra: anytype) !u32 {
994 const payload_offset = @as(u32, @intCast(self.extra.items.len));1050 const payload_offset: u32 = @intCast(self.extra.items.len);
995 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {1051 inline for (@typeInfo(@TypeOf(extra)).Struct.fields) |field| {
996 const field_val = @field(extra, field.name);1052 const field_val = @field(extra, field.name);
997 const word = switch (field.type) {1053 const word: u32 = switch (field.type) {
998 u32 => field_val,1054 u32 => field_val,
999 i32 => @as(u32, @bitCast(field_val)),1055 i32 => @bitCast(field_val),
1000 Ref => @intFromEnum(field_val),1056 Ref => @intFromEnum(field_val),
1001 StorageClass => @intFromEnum(field_val),1057 StorageClass => @intFromEnum(field_val),
1002 String => @intFromEnum(field_val),1058 String => @intFromEnum(field_val),
1059 InternPool.Index => @intFromEnum(field_val),
1003 else => @compileError("Invalid type: " ++ @typeName(field.type)),1060 else => @compileError("Invalid type: " ++ @typeName(field.type)),
1004 };1061 };
1005 self.extra.appendAssumeCapacity(word);1062 self.extra.appendAssumeCapacity(word);
...@@ -1018,10 +1075,11 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t...@@ -1018,10 +1075,11 @@ fn extraDataTrail(self: Self, comptime T: type, offset: u32) struct { data: T, t
1018 const word = self.extra.items[offset + i];1075 const word = self.extra.items[offset + i];
1019 @field(result, field.name) = switch (field.type) {1076 @field(result, field.name) = switch (field.type) {
1020 u32 => word,1077 u32 => word,
1021 i32 => @as(i32, @bitCast(word)),1078 i32 => @bitCast(word),
1022 Ref => @as(Ref, @enumFromInt(word)),1079 Ref => @enumFromInt(word),
1023 StorageClass => @as(StorageClass, @enumFromInt(word)),1080 StorageClass => @enumFromInt(word),
1024 String => @as(String, @enumFromInt(word)),1081 String => @enumFromInt(word),
1082 InternPool.Index => @enumFromInt(word),
1025 else => @compileError("Invalid type: " ++ @typeName(field.type)),1083 else => @compileError("Invalid type: " ++ @typeName(field.type)),
1026 };1084 };
1027 }1085 }
...@@ -1049,7 +1107,7 @@ pub const String = enum(u32) {...@@ -1049,7 +1107,7 @@ pub const String = enum(u32) {
1049 _ = ctx;1107 _ = ctx;
1050 var hasher = std.hash.Wyhash.init(0);1108 var hasher = std.hash.Wyhash.init(0);
1051 hasher.update(a);1109 hasher.update(a);
1052 return @as(u32, @truncate(hasher.final()));1110 return @truncate(hasher.final());
1053 }1111 }
1054 };1112 };
1055};1113};
...@@ -1064,10 +1122,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {...@@ -1064,10 +1122,10 @@ pub fn addString(self: *Self, spv: *Module, str: []const u8) !String {
1064 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);1122 try self.string_bytes.ensureUnusedCapacity(spv.gpa, 1 + str.len);
1065 self.string_bytes.appendSliceAssumeCapacity(str);1123 self.string_bytes.appendSliceAssumeCapacity(str);
1066 self.string_bytes.appendAssumeCapacity(0);1124 self.string_bytes.appendAssumeCapacity(0);
1067 entry.value_ptr.* = @as(u32, @intCast(offset));1125 entry.value_ptr.* = @intCast(offset);
1068 }1126 }
10691127
1070 return @as(String, @enumFromInt(entry.index));1128 return @enumFromInt(entry.index);
1071}1129}
10721130
1073pub fn getString(self: *const Self, ref: String) ?[]const u8 {1131pub fn getString(self: *const Self, ref: String) ?[]const u8 {
src/codegen/spirv/Module.zig-11
...@@ -507,17 +507,6 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {...@@ -507,17 +507,6 @@ pub fn arrayType(self: *Module, len: u32, elem_ty_ref: CacheRef) !CacheRef {
507 } });507 } });
508}508}
509509
510pub fn ptrType(
511 self: *Module,
512 child: CacheRef,
513 storage_class: spec.StorageClass,
514) !CacheRef {
515 return try self.resolve(.{ .ptr_type = .{
516 .storage_class = storage_class,
517 .child_type = child,
518 } });
519}
520
521pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {510pub fn constInt(self: *Module, ty_ref: CacheRef, value: anytype) !IdRef {
522 const ty = self.cache.lookup(ty_ref).int_type;511 const ty = self.cache.lookup(ty_ref).int_type;
523 const Value = Cache.Key.Int.Value;512 const Value = Cache.Key.Int.Value;
test/behavior/bugs/12000.zig-1
...@@ -9,7 +9,6 @@ test {...@@ -9,7 +9,6 @@ test {
9 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1312
14 var t: T = .{ .next = null };13 var t: T = .{ .next = null };
15 try std.testing.expect(t.next == null);14 try std.testing.expect(t.next == null);
test/behavior/bugs/1735.zig-1
...@@ -44,7 +44,6 @@ const a = struct {...@@ -44,7 +44,6 @@ const a = struct {
44test "initialization" {44test "initialization" {
45 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;45 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
46 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO46 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
4847
49 var t = a.init();48 var t = a.init();
50 try std.testing.expect(t.foo.len == 0);49 try std.testing.expect(t.foo.len == 0);
test/behavior/bugs/1914.zig-4
...@@ -12,8 +12,6 @@ const b_list: []B = &[_]B{};...@@ -12,8 +12,6 @@ const b_list: []B = &[_]B{};
12const a = A{ .b_list_pointer = &b_list };12const a = A{ .b_list_pointer = &b_list };
1313
14test "segfault bug" {14test "segfault bug" {
15 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
16
17 const assert = std.debug.assert;15 const assert = std.debug.assert;
18 const obj = B{ .a_pointer = &a };16 const obj = B{ .a_pointer = &a };
19 assert(obj.a_pointer == &a); // this makes zig crash17 assert(obj.a_pointer == &a); // this makes zig crash
...@@ -30,7 +28,5 @@ pub const B2 = struct {...@@ -30,7 +28,5 @@ pub const B2 = struct {
30var b_value = B2{ .pointer_array = &[_]*A2{} };28var b_value = B2{ .pointer_array = &[_]*A2{} };
3129
32test "basic stuff" {30test "basic stuff" {
33 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
34
35 std.debug.assert(&b_value == &b_value);31 std.debug.assert(&b_value == &b_value);
36}32}
test/behavior/bugs/2006.zig-1
...@@ -7,7 +7,6 @@ const S = struct {...@@ -7,7 +7,6 @@ const S = struct {
7};7};
8test "bug 2006" {8test "bug 2006" {
9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1110
12 var a: S = undefined;11 var a: S = undefined;
13 a = S{ .p = undefined };12 a = S{ .p = undefined };
test/behavior/bugs/3007.zig-1
...@@ -22,7 +22,6 @@ test "fixed" {...@@ -22,7 +22,6 @@ test "fixed" {
22 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;22 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO23 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO24 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
2625
27 default_foo = get_foo() catch null; // This Line26 default_foo = get_foo() catch null; // This Line
28 try std.testing.expect(!default_foo.?.free);27 try std.testing.expect(!default_foo.?.free);
test/behavior/bugs/6947.zig-1
...@@ -8,7 +8,6 @@ test {...@@ -8,7 +8,6 @@ test {
8 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO8 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO9 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1211
13 var slice: []void = undefined;12 var slice: []void = undefined;
14 destroy(&slice[0]);13 destroy(&slice[0]);
test/behavior/bugs/7325.zig-1
...@@ -81,7 +81,6 @@ test {...@@ -81,7 +81,6 @@ test {
81 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO81 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
82 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO82 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
83 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO83 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
84 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
8584
86 var param: ParamType = .{85 var param: ParamType = .{
87 .one_of = .{ .name = "name" },86 .one_of = .{ .name = "name" },
test/behavior/error.zig-1
...@@ -943,7 +943,6 @@ test "returning an error union containing a type with no runtime bits" {...@@ -943,7 +943,6 @@ test "returning an error union containing a type with no runtime bits" {
943test "try used in recursive function with inferred error set" {943test "try used in recursive function with inferred error set" {
944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO944 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
945 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO945 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
946 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
947946
948 const Value = union(enum) {947 const Value = union(enum) {
949 values: []const @This(),948 values: []const @This(),
test/behavior/eval.zig-4
...@@ -391,7 +391,6 @@ test "return 0 from function that has u0 return type" {...@@ -391,7 +391,6 @@ test "return 0 from function that has u0 return type" {
391test "statically initialized struct" {391test "statically initialized struct" {
392 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO392 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO393 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
394 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
395394
396 st_init_str_foo.x += 1;395 st_init_str_foo.x += 1;
397 try expect(st_init_str_foo.x == 14);396 try expect(st_init_str_foo.x == 14);
...@@ -498,7 +497,6 @@ test "comptime shlWithOverflow" {...@@ -498,7 +497,6 @@ test "comptime shlWithOverflow" {
498test "const ptr to variable data changes at runtime" {497test "const ptr to variable data changes at runtime" {
499 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO498 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
500 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO499 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
502500
503 try expect(foo_ref.name[0] == 'a');501 try expect(foo_ref.name[0] == 'a');
504 foo_ref.name = "b";502 foo_ref.name = "b";
...@@ -1551,8 +1549,6 @@ test "comptime function turns function value to function pointer" {...@@ -1551,8 +1549,6 @@ test "comptime function turns function value to function pointer" {
1551}1549}
15521550
1553test "container level const and var have unique addresses" {1551test "container level const and var have unique addresses" {
1554 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1555
1556 const S = struct {1552 const S = struct {
1557 x: i32,1553 x: i32,
1558 y: i32,1554 y: i32,
test/behavior/generics.zig-1
...@@ -205,7 +205,6 @@ fn foo2(arg: anytype) bool {...@@ -205,7 +205,6 @@ fn foo2(arg: anytype) bool {
205205
206test "generic struct" {206test "generic struct" {
207 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO207 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
208 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
209208
210 var a1 = GenNode(i32){209 var a1 = GenNode(i32){
211 .value = 13,210 .value = 13,
test/behavior/null.zig-1
...@@ -185,7 +185,6 @@ test "unwrap optional which is field of global var" {...@@ -185,7 +185,6 @@ test "unwrap optional which is field of global var" {
185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
189188
190 struct_with_optional.field = null;189 struct_with_optional.field = null;
191 if (struct_with_optional.field) |payload| {190 if (struct_with_optional.field) |payload| {
test/behavior/optional.zig-1
...@@ -193,7 +193,6 @@ test "nested orelse" {...@@ -193,7 +193,6 @@ test "nested orelse" {
193test "self-referential struct through a slice of optional" {193test "self-referential struct through a slice of optional" {
194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO194 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO195 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
197196
198 const S = struct {197 const S = struct {
199 const Node = struct {198 const Node = struct {
test/behavior/ptrcast.zig-2
...@@ -130,7 +130,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {...@@ -130,7 +130,6 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO131 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO132 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
134133
135 // Test lowering a field ptr134 // Test lowering a field ptr
136 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };135 comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
...@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr" {...@@ -153,7 +152,6 @@ test "lower reinterpreted comptime field ptr" {
153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
155 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO154 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
156 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
157155
158 // Test lowering a field ptr156 // Test lowering a field ptr
159 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };157 comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
test/behavior/struct.zig-6
...@@ -292,7 +292,6 @@ const Val = struct {...@@ -292,7 +292,6 @@ const Val = struct {
292test "struct point to self" {292test "struct point to self" {
293 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;293 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
294 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO294 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
296295
297 var root: Node = undefined;296 var root: Node = undefined;
298 root.val.x = 1;297 root.val.x = 1;
...@@ -347,7 +346,6 @@ test "self-referencing struct via array member" {...@@ -347,7 +346,6 @@ test "self-referencing struct via array member" {
347 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;346 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
348 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO347 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
349 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO348 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
350 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
351349
352 const T = struct {350 const T = struct {
353 children: [1]*@This(),351 children: [1]*@This(),
...@@ -370,7 +368,6 @@ const EmptyStruct = struct {...@@ -370,7 +368,6 @@ const EmptyStruct = struct {
370368
371test "align 1 field before self referential align 8 field as slice return type" {369test "align 1 field before self referential align 8 field as slice return type" {
372 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO370 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
374371
375 const result = alloc(Expr);372 const result = alloc(Expr);
376 try expect(result.len == 0);373 try expect(result.len == 0);
...@@ -736,7 +733,6 @@ test "packed struct with u0 field access" {...@@ -736,7 +733,6 @@ test "packed struct with u0 field access" {
736test "access to global struct fields" {733test "access to global struct fields" {
737 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO734 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
738 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO735 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
739 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
740736
741 g_foo.bar.value = 42;737 g_foo.bar.value = 42;
742 try expect(g_foo.bar.value == 42);738 try expect(g_foo.bar.value == 42);
...@@ -1423,7 +1419,6 @@ test "fieldParentPtr of a zero-bit field" {...@@ -1423,7 +1419,6 @@ test "fieldParentPtr of a zero-bit field" {
14231419
1424test "struct field has a pointer to an aligned version of itself" {1420test "struct field has a pointer to an aligned version of itself" {
1425 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1421 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1426 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
14271422
1428 const E = struct {1423 const E = struct {
1429 next: *align(1) @This(),1424 next: *align(1) @This(),
...@@ -1519,7 +1514,6 @@ test "function pointer in struct returns the struct" {...@@ -1519,7 +1514,6 @@ test "function pointer in struct returns the struct" {
15191514
1520test "no dependency loop on optional field wrapped in generic function" {1515test "no dependency loop on optional field wrapped in generic function" {
1521 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1522 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
15231517
1524 const S = struct {1518 const S = struct {
1525 fn Atomic(comptime T: type) type {1519 fn Atomic(comptime T: type) type {
test/behavior/struct_contains_null_ptr_itself.zig-1
...@@ -5,7 +5,6 @@ const builtin = @import("builtin");...@@ -5,7 +5,6 @@ const builtin = @import("builtin");
5test "struct contains null pointer which contains original struct" {5test "struct contains null pointer which contains original struct" {
6 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;6 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO7 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
98
10 var x: ?*NodeLineComment = null;9 var x: ?*NodeLineComment = null;
11 try expect(x == null);10 try expect(x == null);
test/behavior/struct_contains_slice_of_itself.zig-2
...@@ -13,7 +13,6 @@ const NodeAligned = struct {...@@ -13,7 +13,6 @@ const NodeAligned = struct {
1313
14test "struct contains slice of itself" {14test "struct contains slice of itself" {
15 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO15 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
1716
18 var other_nodes = [_]Node{17 var other_nodes = [_]Node{
19 Node{18 Node{
...@@ -54,7 +53,6 @@ test "struct contains slice of itself" {...@@ -54,7 +53,6 @@ test "struct contains slice of itself" {
54test "struct contains aligned slice of itself" {53test "struct contains aligned slice of itself" {
55 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO54 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO55 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
5856
59 var other_nodes = [_]NodeAligned{57 var other_nodes = [_]NodeAligned{
60 NodeAligned{58 NodeAligned{
test/behavior/union.zig-10
...@@ -399,7 +399,6 @@ test "tagged union with no payloads" {...@@ -399,7 +399,6 @@ test "tagged union with no payloads" {
399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
403402
404 const a = UnionEnumNoPayloads{ .B = {} };403 const a = UnionEnumNoPayloads{ .B = {} };
405 switch (a) {404 switch (a) {
...@@ -474,7 +473,6 @@ test "update the tag value for zero-sized unions" {...@@ -474,7 +473,6 @@ test "update the tag value for zero-sized unions" {
474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;473 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
475 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;474 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO475 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
478476
479 const S = union(enum) {477 const S = union(enum) {
480 U0: void,478 U0: void,
...@@ -515,7 +513,6 @@ test "method call on an empty union" {...@@ -515,7 +513,6 @@ test "method call on an empty union" {
515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;513 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
516 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
517 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO515 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
518 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
519516
520 const S = struct {517 const S = struct {
521 const MyUnion = union(MyUnionTag) {518 const MyUnion = union(MyUnionTag) {
...@@ -593,7 +590,6 @@ test "tagged union with all void fields but a meaningful tag" {...@@ -593,7 +590,6 @@ test "tagged union with all void fields but a meaningful tag" {
593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;590 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;591 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO592 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
597593
598 const S = struct {594 const S = struct {
599 const B = union(enum) {595 const B = union(enum) {
...@@ -795,7 +791,6 @@ test "@unionInit stored to a const" {...@@ -795,7 +791,6 @@ test "@unionInit stored to a const" {
795 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO791 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
796 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO792 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
797 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO793 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
798 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
799794
800 const S = struct {795 const S = struct {
801 const U = union(enum) {796 const U = union(enum) {
...@@ -867,7 +862,6 @@ test "union no tag with struct member" {...@@ -867,7 +862,6 @@ test "union no tag with struct member" {
867 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO862 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
868 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
869 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO864 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
870 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
871865
872 const Struct = struct {};866 const Struct = struct {};
873 const Union = union {867 const Union = union {
...@@ -1079,7 +1073,6 @@ test "@unionInit on union with tag but no fields" {...@@ -1079,7 +1073,6 @@ test "@unionInit on union with tag but no fields" {
1079 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1073 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1080 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1074 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1081 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1075 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1082 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
10831076
1084 const S = struct {1077 const S = struct {
1085 const Type = enum(u8) { no_op = 105 };1078 const Type = enum(u8) { no_op = 105 };
...@@ -1128,7 +1121,6 @@ test "global variable struct contains union initialized to non-most-aligned fiel...@@ -1128,7 +1121,6 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1128 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1129 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1122 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1130 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1123 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1131 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
11321124
1133 const T = struct {1125 const T = struct {
1134 const U = union(enum) {1126 const U = union(enum) {
...@@ -1348,7 +1340,6 @@ test "union field ptr - zero sized payload" {...@@ -1348,7 +1340,6 @@ test "union field ptr - zero sized payload" {
1348 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1349 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1350 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1342 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1351 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13521343
1353 const U = union {1344 const U = union {
1354 foo: void,1345 foo: void,
...@@ -1363,7 +1354,6 @@ test "union field ptr - zero sized field" {...@@ -1363,7 +1354,6 @@ test "union field ptr - zero sized field" {
1363 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO1354 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1364 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1365 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO1356 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1366 if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest;
13671357
1368 const U = union {1358 const U = union {
1369 foo: void,1359 foo: void,