Commit a9a91a5d49070acaa783d9d65f34a652659160c9 | zig

author	Cody Tapscott <topolarity@tapscott.me> 2022-03-21 12:18:58-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2022-03-23 16:29:38-04:00
log	a9a91a5d49070acaa783d9d65f34a652659160c9
tree	4cd4783cdaa0c5c1303dcb673ede437196fe503e
parent	2f9264d8dcedba3a75dcf9d6a31b82447dfc57e8

stage2 CBE: Improve support for unions and error sets

This includes various fixes/improvements to the C backend to improve
error/union support. It also fixes up our handling of decls, where some
decls were not correctly marked alive.

4 files changed, 172 insertions(+), 55 deletions(-)

src
- codegen
  - c.zig
test
- behavior

src/codegen/c.zig+105-35

 @@ -375,8 +375,6 @@ pub const DeclGen = struct {
         val: Value,
         decl: *Decl,
     ) error{ OutOfMemory, AnalysisFail }!void {
-        decl.markAlive();
         const target = dg.module.getTarget();
         if (ty.isSlice()) {
 @@ -461,12 +459,14 @@ pub const DeclGen = struct {
         }
     }
-    // Renders a "child" pointer (e.g. ElemPtr, FieldPtr) by recursing
+    // Renders a "parent" pointer by recursing to the root decl/variable
-    // to the root decl/variable that acts as its parent
+    // that its contents are defined with respect to.
     //
-    // Used for .elem_ptr, .field_ptr, .opt_payload_ptr, .eu_payload_ptr, since
+    // Used for .elem_ptr, .field_ptr, .opt_payload_ptr, .eu_payload_ptr
-    // the Type of their container cannot be retrieved from their own Type
+    fn renderParentPtr(dg: *DeclGen, writer: anytype, ptr_val: Value, ptr_ty: Type) error{ OutOfMemory, AnalysisFail }!void {
-    fn renderChildPtr(dg: *DeclGen, writer: anytype, ptr_val: Value) error{ OutOfMemory, AnalysisFail }!Type {
+        try writer.writeByte('(');
+        try dg.renderTypecast(writer, ptr_ty);
+        try writer.writeByte(')');
         switch (ptr_val.tag()) {
             .decl_ref_mut, .decl_ref, .variable => {
                 const decl = switch (ptr_val.tag()) {
 @@ -475,16 +475,12 @@ pub const DeclGen = struct {
                     .variable => ptr_val.castTag(.variable).?.data.owner_decl,
                     else => unreachable,
                 };
-                try dg.renderDeclName(writer, decl);
+                try dg.renderDeclValue(writer, ptr_ty, ptr_val, decl);
-                return decl.ty;
             },
             .field_ptr => {
                 const field_ptr = ptr_val.castTag(.field_ptr).?.data;
+                const container_ty = field_ptr.container_ty;
                 const index = field_ptr.field_index;
-                try writer.writeAll("&(");
-                const container_ty = try dg.renderChildPtr(writer, field_ptr.container_ptr);
                 const field_name = switch (container_ty.zigTypeTag()) {
                     .Struct => container_ty.structFields().keys()[index],
                     .Union => container_ty.unionFields().keys()[index],
 @@ -495,19 +491,48 @@ pub const DeclGen = struct {
                     .Union => container_ty.unionFields().values()[index].ty,
                     else => unreachable,
                 };
-                try writer.print(").{ }", .{fmtIdent(field_name)});
+                var container_ptr_ty_pl: Type.Payload.ElemType = .{
+                    .base = .{ .tag = .c_mut_pointer },
+                    .data = field_ptr.container_ty,
+                };
+                const container_ptr_ty = Type.initPayload(&container_ptr_ty_pl.base);
-                return field_ty;
+                if (field_ty.hasRuntimeBitsIgnoreComptime()) {
+                    try writer.writeAll("&(");
+                    try dg.renderParentPtr(writer, field_ptr.container_ptr, container_ptr_ty);
+                    if (field_ptr.container_ty.tag() == .union_tagged) {
+                        try writer.print(")->payload.{ }", .{fmtIdent(field_name)});
+                    } else {
+                        try writer.print(")->{ }", .{fmtIdent(field_name)});
+                    }
+                } else {
+                    try dg.renderParentPtr(writer, field_ptr.container_ptr, field_ty);
+                }
             },
             .elem_ptr => {
                 const elem_ptr = ptr_val.castTag(.elem_ptr).?.data;
+                var elem_ptr_ty_pl: Type.Payload.ElemType = .{
+                    .base = .{ .tag = .c_mut_pointer },
+                    .data = elem_ptr.elem_ty,
+                };
+                const elem_ptr_ty = Type.initPayload(&elem_ptr_ty_pl.base);
                 try writer.writeAll("&(");
-                const container_ty = try dg.renderChildPtr(writer, elem_ptr.array_ptr);
+                try dg.renderParentPtr(writer, elem_ptr.array_ptr, elem_ptr_ty);
                 try writer.print(")[{d}]", .{elem_ptr.index});
-                return container_ty.childType();
             },
-            .opt_payload_ptr => return dg.fail("implement renderChildPtr for optional payload", .{}),
+            .opt_payload_ptr, .eu_payload_ptr => {
-            .eu_payload_ptr => return dg.fail("implement renderChildPtr for error union payload", .{}),
+                const payload_ptr = ptr_val.cast(Value.Payload.PayloadPtr).?.data;
+                var container_ptr_ty_pl: Type.Payload.ElemType = .{
+                    .base = .{ .tag = .c_mut_pointer },
+                    .data = payload_ptr.container_ty,
+                };
+                const container_ptr_ty = Type.initPayload(&container_ptr_ty_pl.base);
+                try writer.writeAll("&(");
+                try dg.renderParentPtr(writer, payload_ptr.container_ptr, container_ptr_ty);
+                try writer.writeAll(")->payload");
+            },
             else => unreachable,
         }
     }
 @@ -559,6 +584,13 @@ pub const DeclGen = struct {
             .Int => switch (val.tag()) {
                 .int_big_positive => try dg.renderBigIntConst(writer, val.castTag(.int_big_positive).?.asBigInt(), ty.isSignedInt()),
                 .int_big_negative => try dg.renderBigIntConst(writer, val.castTag(.int_big_negative).?.asBigInt(), true),
+                .field_ptr,
+                .elem_ptr,
+                .opt_payload_ptr,
+                .eu_payload_ptr,
+                .decl_ref_mut,
+                .decl_ref,
+                => try dg.renderParentPtr(writer, val, ty),
                 else => {
                     if (ty.isSignedInt())
                         return writer.print("{d}", .{val.toSignedInt()});
 @@ -586,10 +618,6 @@ pub const DeclGen = struct {
                 // to the assigned pointer type. Note this is just a hack to fix warnings from ordered comparisons (<, >, etc)
                 // between pointers and 0, which is an extension to begin with.
                 .zero => try writer.writeByte('0'),
-                .decl_ref => {
-                    const decl = val.castTag(.decl_ref).?.data;
-                    return dg.renderDeclValue(writer, ty, val, decl);
-                },
                 .variable => {
                     const decl = val.castTag(.variable).?.data.owner_decl;
                     return dg.renderDeclValue(writer, ty, val, decl);
 @@ -606,9 +634,6 @@ pub const DeclGen = struct {
                     try dg.renderValue(writer, Type.usize, slice.len);
                     try writer.writeAll("}");
                 },
-                .field_ptr, .elem_ptr, .opt_payload_ptr, .eu_payload_ptr => {
-                    _ = try dg.renderChildPtr(writer, val);
-                },
                 .function => {
                     const func = val.castTag(.function).?.data;
                     try dg.renderDeclName(writer, func.owner_decl);
 @@ -622,6 +647,13 @@ pub const DeclGen = struct {
                     try dg.renderTypecast(writer, ty);
                     try writer.print(")0x{x}u)", .{val.toUnsignedInt(target)});
                 },
+                .field_ptr,
+                .elem_ptr,
+                .opt_payload_ptr,
+                .eu_payload_ptr,
+                .decl_ref_mut,
+                .decl_ref,
+                => try dg.renderParentPtr(writer, val, ty),
                 else => unreachable,
             },
             .Array => {
 @@ -1326,7 +1358,7 @@ pub const DeclGen = struct {
                 return w.writeAll(name);
             },
             .Struct => {
-                const name = dg.getTypedefName(t) orelse if (t.isTuple())
+                const name = dg.getTypedefName(t) orelse if (t.isTuple() or t.tag() == .anon_struct)
                     try dg.renderTupleTypedef(t)
                 else
                     try dg.renderStructTypedef(t);
 @@ -1346,11 +1378,11 @@ pub const DeclGen = struct {
                 try dg.renderType(w, int_tag_ty);
             },
+            .Opaque => return w.writeAll("void"),
             .Frame,
             .AnyFrame,
             .Vector,
-            .Opaque,
             => |tag| return dg.fail("TODO: C backend: implement value of type {s}", .{
                 @tagName(tag),
             }),
 @@ -1497,6 +1529,8 @@ pub const DeclGen = struct {
     }
     fn renderDeclName(dg: DeclGen, writer: anytype, decl: *Decl) !void {
+        decl.markAlive();
         if (dg.module.decl_exports.get(decl)) |exports| {
             return writer.writeAll(exports[0].options.name);
         } else if (decl.val.tag() == .extern_fn) {
 @@ -3188,7 +3222,7 @@ fn structFieldPtr(f: *Function, inst: Air.Inst.Index, struct_ptr_ty: Type, struc
             field_name = fields.keys()[index];
             field_val_ty = fields.values()[index].ty;
         },
-        .tuple => {
+        .tuple, .anon_struct => {
             const tuple = struct_ty.tupleFields();
             if (tuple.values[index].tag() != .unreachable_value) return CValue.none;
 @@ -3203,9 +3237,17 @@ fn structFieldPtr(f: *Function, inst: Air.Inst.Index, struct_ptr_ty: Type, struc
     const inst_ty = f.air.typeOfIndex(inst);
     const local = try f.allocLocal(inst_ty, .Const);
-    try writer.print(" = &", .{});
+    if (field_val_ty.hasRuntimeBitsIgnoreComptime()) {
-    try f.writeCValueDeref(writer, struct_ptr);
+        try writer.writeAll(" = &");
-    try writer.print(".{s}{ };\n", .{ payload, fmtIdent(field_name) });
+        try f.writeCValueDeref(writer, struct_ptr);
+        try writer.print(".{s}{ };\n", .{ payload, fmtIdent(field_name) });
+    } else {
+        try writer.writeAll(" = (");
+        try f.renderTypecast(writer, inst_ty);
+        try writer.writeByte(')');
+        try f.writeCValue(writer, struct_ptr);
+        try writer.writeAll(";\n");
+    }
     return local;
 }
 @@ -3223,7 +3265,7 @@ fn airStructFieldVal(f: *Function, inst: Air.Inst.Index) !CValue {
     const field_name = switch (struct_ty.tag()) {
         .@"struct" => struct_ty.structFields().keys()[extra.field_index],
         .@"union", .union_tagged => struct_ty.unionFields().keys()[extra.field_index],
-        .tuple => blk: {
+        .tuple, .anon_struct => blk: {
             const tuple = struct_ty.tupleFields();
             if (tuple.values[extra.field_index].tag() != .unreachable_value) return CValue.none;
 @@ -3348,8 +3390,36 @@ fn airWrapErrUnionErr(f: *Function, inst: Air.Inst.Index) !CValue {
 }
 fn airErrUnionPayloadPtrSet(f: *Function, inst: Air.Inst.Index) !CValue {
-    _ = inst;
+    const writer = f.object.writer();
-    return f.fail("TODO: C backend: implement airErrUnionPayloadPtrSet", .{});
+    const ty_op = f.air.instructions.items(.data)[inst].ty_op;
+    const operand = try f.resolveInst(ty_op.operand);
+    const error_union_ty = f.air.typeOf(ty_op.operand).childType();
+    const error_ty = error_union_ty.errorUnionSet();
+    const payload_ty = error_union_ty.errorUnionPayload();
+    // First, set the non-error value.
+    if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
+        try f.writeCValueDeref(writer, operand);
+        try writer.writeAll(" = ");
+        try f.object.dg.renderValue(writer, error_ty, Value.zero);
+        try writer.writeAll(";\n ");
+        return operand;
+    }
+    try f.writeCValueDeref(writer, operand);
+    try writer.writeAll(".error = ");
+    try f.object.dg.renderValue(writer, error_ty, Value.zero);
+    try writer.writeAll(";\n");
+    // Then return the payload pointer (only if it is used)
+    if (f.liveness.isUnused(inst)) return CValue.none;
+    const local = try f.allocLocal(f.air.typeOfIndex(inst), .Const);
+    try writer.writeAll(" = &(");
+    try f.writeCValueDeref(writer, operand);
+    try writer.writeAll(").payload;\n");
+    return local;
 }
 fn airWrapErrUnionPay(f: *Function, inst: Air.Inst.Index) !CValue {

test/behavior/error.zig+12-7

 @@ -1,10 +1,20 @@
 const builtin = @import("builtin");
 const std = @import("std");
 const expect = std.testing.expect;
-const expectError = std.testing.expectError;
 const expectEqual = std.testing.expectEqual;
 const mem = std.mem;
+/// A more basic implementation of std.testing.expectError which
+/// does not require formatter/printing support
+fn expectError(expected_err: anyerror, observed_err_union: anytype) !void {
+    if (observed_err_union) {
+        return error.TestExpectedError;
+    } else |err| if (err == expected_err) {
+        return; // Success
+    }
+    return error.TestExpectedError;
+}
 test "error values" {
     const a = @errorToInt(error.err1);
     const b = @errorToInt(error.err2);
 @@ -329,7 +339,6 @@ fn intLiteral(str: []const u8) !?i64 {
 test "nested error union function call in optional unwrap" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 @@ -377,7 +386,6 @@ test "nested error union function call in optional unwrap" {
 }
 test "return function call to error set from error union function" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 @@ -410,7 +418,6 @@ test "optional error set is the same size as error set" {
 }
 test "nested catch" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 @@ -471,7 +478,6 @@ test "function pointer with return type that is error union with payload which i
 test "return result loc as peer result loc in inferred error set function" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 @@ -503,7 +509,6 @@ test "return result loc as peer result loc in inferred error set function" {
 }
 test "error payload type is correctly resolved" {
-    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 @@ -519,7 +524,7 @@ test "error payload type is correctly resolved" {
         }
     };
-    try expectEqual(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create());
+    try expect(std.meta.eql(MyIntWrapper{ .x = 42 }, try MyIntWrapper.create()));
 }
 test "error union comptime caching" {

test/behavior/ptrcast.zig+55-7

...	@@ -39,7 +39,6 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void {	...	@@ -39,7 +39,6 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void {
39	}	39	}
40		40
41	test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" {	41	test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" {
42	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
44	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
45		44
...	@@ -80,9 +79,9 @@ fn testReinterpretBytesAsExternStruct() !void {	...	@@ -80,9 +79,9 @@ fn testReinterpretBytesAsExternStruct() !void {
80	try expect(val == 5);	79	try expect(val == 5);
81	}	80	}
82		81
83	test "reinterpret bytes of an extern struct into another" {	82	test "reinterpret bytes of an extern struct (with under-aligned fields) into another" {
84	if (builtin.zig_backend == .stage1) return error.SkipZigTest;	83	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
85	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	84	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: Under-aligned fields are not yet supported in the CBE
86	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	85	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
87		86
88	try testReinterpretExternStructAsExternStruct();	87	try testReinterpretExternStructAsExternStruct();
...	@@ -106,12 +105,39 @@ fn testReinterpretExternStructAsExternStruct() !void {	...	@@ -106,12 +105,39 @@ fn testReinterpretExternStructAsExternStruct() !void {
106	try expect(val == 5);	105	try expect(val == 5);
107	}	106	}
108		107
109	test "lower reinterpreted comptime field ptr" {	108	test "reinterpret bytes of an extern struct into another" {
		109	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
		110	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		111
		112	try testReinterpretOverAlignedExternStructAsExternStruct();
		113	comptime try testReinterpretOverAlignedExternStructAsExternStruct();
		114	}
		115
		116	fn testReinterpretOverAlignedExternStructAsExternStruct() !void {
		117	const S1 = extern struct {
		118	a: u32,
		119	b: u32,
		120	c: u8,
		121	};
		122	comptime var bytes: S1 = .{ .a = 0, .b = 0, .c = 5 };
		123
		124	const S2 = extern struct {
		125	a0: u32,
		126	a1: u16,
		127	a2: u16,
		128	c: u8,
		129	};
		130	var ptr = @ptrCast(*const S2, &bytes);
		131	var val = ptr.c;
		132	try expect(val == 5);
		133	}
		134
		135	test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
110	if (builtin.zig_backend == .stage1) return error.SkipZigTest;	136	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
113	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	139	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
114	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO	140	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO: CBE does not yet support under-aligned fields
115	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO	141	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
116		142
117	// Test lowering a field ptr	143	// Test lowering a field ptr
...	@@ -131,8 +157,31 @@ test "lower reinterpreted comptime field ptr" {	...	@@ -131,8 +157,31 @@ test "lower reinterpreted comptime field ptr" {
131	try expect(val2.* == 5);	157	try expect(val2.* == 5);
132	}	158	}
133		159
		160	test "lower reinterpreted comptime field ptr" {
		161	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
		162	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
		163	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
		164	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
		165	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
		166
		167	// Test lowering a field ptr
		168	comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
		169	const S = extern struct {
		170	a: u32,
		171	c: u8,
		172	};
		173	comptime var ptr = @ptrCast(*const S, &bytes);
		174	var val = &ptr.c;
		175	try expect(val.* == 5);
		176
		177	// Test lowering an elem ptr
		178	comptime var src_value = S{ .a = 15, .c = 5 };
		179	comptime var ptr2 = @ptrCast(*[@sizeOf(S)]u8, &src_value);
		180	var val2 = &ptr2[4];
		181	try expect(val2.* == 5);
		182	}
		183
134	test "reinterpret struct field at comptime" {	184	test "reinterpret struct field at comptime" {
135	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
136	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	185	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
137	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	186	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
138		187
...	@@ -164,7 +213,6 @@ test "comptime ptrcast keeps larger alignment" {	...	@@ -164,7 +213,6 @@ test "comptime ptrcast keeps larger alignment" {
164	}	213	}
165		214
166	test "implicit optional pointer to optional anyopaque pointer" {	215	test "implicit optional pointer to optional anyopaque pointer" {
167	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
168	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	216	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
169	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	217	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
170		218

test/behavior/union.zig-6

...	@@ -436,8 +436,6 @@ test "global union with single field is correctly initialized" {	...	@@ -436,8 +436,6 @@ test "global union with single field is correctly initialized" {
436	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	436	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
438		438
439	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
440
441	glbl = Foo1{	439	glbl = Foo1{
442	.f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 },	440	.f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 },
443	};	441	};
...	@@ -456,8 +454,6 @@ test "initialize global array of union" {	...	@@ -456,8 +454,6 @@ test "initialize global array of union" {
456	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;	454	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;	455	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
458		456
459	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
460
461	glbl_array[1] = FooUnion{ .U1 = 2 };	457	glbl_array[1] = FooUnion{ .U1 = 2 };
462	glbl_array[0] = FooUnion{ .U0 = 1 };	458	glbl_array[0] = FooUnion{ .U0 = 1 };
463	try expect(glbl_array[0].U0 == 1);	459	try expect(glbl_array[0].U0 == 1);
...	@@ -1033,7 +1029,6 @@ test "switching on non exhaustive union" {	...	@@ -1033,7 +1029,6 @@ test "switching on non exhaustive union" {
1033	}	1029	}
1034		1030
1035	test "containers with single-field enums" {	1031	test "containers with single-field enums" {
1036	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1037	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1032	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1038	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1033	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1039		1034
...	@@ -1113,7 +1108,6 @@ test "union enum type gets a separate scope" {	...	@@ -1113,7 +1108,6 @@ test "union enum type gets a separate scope" {
1113	}	1108	}
1114		1109
1115	test "global variable struct contains union initialized to non-most-aligned field" {	1110	test "global variable struct contains union initialized to non-most-aligned field" {
1116	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1117	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO	1111	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1118	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO	1112	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO	1113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO