authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-03-01 09:14:23+01:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-03-01 09:14:23+01:00
logec54ceee6d34a61734ac6759ffdbd75248a2f3d7
tree21f600733435a9f63674c131b3d1df421b0618a7
parentf5a31cb0d693ef3c07da7f446c95999cef34488b
parentcfbc3537ef0b3a73d5b8fdd358cf3bb831935861
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11016 from ziglang/x64-more-codegen

25 files changed, 162 insertions(+), 207 deletions(-)

src/arch/x86_64/CodeGen.zig+140-109
......@@ -1738,14 +1738,22 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
17381738 return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
17391739 }
17401740 const err_union_ty = self.air.typeOf(ty_op.operand);
1741 const err_ty = err_union_ty.errorUnionSet();
17411742 const payload_ty = err_union_ty.errorUnionPayload();
17421743 const operand = try self.resolveInst(ty_op.operand);
1744 operand.freezeIfRegister(&self.register_manager);
1745 defer operand.unfreezeIfRegister(&self.register_manager);
1746
17431747 const result: MCValue = result: {
17441748 if (!payload_ty.hasRuntimeBits()) break :result operand;
17451749 switch (operand) {
17461750 .stack_offset => |off| {
17471751 break :result MCValue{ .stack_offset = off };
17481752 },
1753 .register => {
1754 // TODO reuse operand
1755 break :result try self.copyToRegisterWithInstTracking(inst, err_ty, operand);
1756 },
17491757 else => return self.fail("TODO implement unwrap_err_err for {}", .{operand}),
17501758 }
17511759 };
......@@ -1763,13 +1771,25 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
17631771 if (!payload_ty.hasRuntimeBits()) break :result MCValue.none;
17641772
17651773 const operand = try self.resolveInst(ty_op.operand);
1774 operand.freezeIfRegister(&self.register_manager);
1775 defer operand.unfreezeIfRegister(&self.register_manager);
1776
17661777 const err_ty = err_union_ty.errorUnionSet();
1767 const err_abi_size = @intCast(u32, err_ty.abiSize(self.target.*));
17681778 switch (operand) {
17691779 .stack_offset => |off| {
1780 const err_abi_size = @intCast(u32, err_ty.abiSize(self.target.*));
17701781 const offset = off - @intCast(i32, err_abi_size);
17711782 break :result MCValue{ .stack_offset = offset };
17721783 },
1784 .register => {
1785 // TODO reuse operand
1786 const shift = @intCast(u6, err_ty.bitSize(self.target.*));
1787 const result = try self.copyToRegisterWithInstTracking(inst, err_union_ty, operand);
1788 try self.shiftRegister(result.register.to64(), shift);
1789 break :result MCValue{
1790 .register = registerAlias(result.register, @intCast(u32, payload_ty.abiSize(self.target.*))),
1791 };
1792 },
17731793 else => return self.fail("TODO implement unwrap_err_payload for {}", .{operand}),
17741794 }
17751795 };
......@@ -2013,42 +2033,44 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
20132033 self.register_manager.freezeRegs(&.{offset_reg});
20142034 defer self.register_manager.unfreezeRegs(&.{offset_reg});
20152035
2016 const addr_reg = blk: {
2017 const off = inner: {
2018 switch (array) {
2019 .register => {
2020 const off = @intCast(i32, try self.allocMem(
2021 inst,
2022 @intCast(u32, array_ty.abiSize(self.target.*)),
2023 array_ty.abiAlignment(self.target.*),
2024 ));
2025 try self.genSetStack(array_ty, off, array, .{});
2026 break :inner off;
2027 },
2028 .stack_offset => |off| {
2029 break :inner off;
2030 },
2031 .memory,
2032 .got_load,
2033 .direct_load,
2034 => {
2035 break :blk try self.loadMemPtrIntoRegister(Type.usize, array);
2036 },
2037 else => return self.fail("TODO implement array_elem_val when array is {}", .{array}),
2038 }
2039 };
2040 const addr_reg = try self.register_manager.allocReg(null);
2041 // lea reg, [rbp]
2042 _ = try self.addInst(.{
2043 .tag = .lea,
2044 .ops = (Mir.Ops{
2045 .reg1 = addr_reg.to64(),
2046 .reg2 = .rbp,
2047 }).encode(),
2048 .data = .{ .imm = @bitCast(u32, -off) },
2049 });
2050 break :blk addr_reg.to64();
2051 };
2036 const addr_reg = try self.register_manager.allocReg(null);
2037 switch (array) {
2038 .register => {
2039 const off = @intCast(i32, try self.allocMem(
2040 inst,
2041 @intCast(u32, array_ty.abiSize(self.target.*)),
2042 array_ty.abiAlignment(self.target.*),
2043 ));
2044 try self.genSetStack(array_ty, off, array, .{});
2045 // lea reg, [rbp]
2046 _ = try self.addInst(.{
2047 .tag = .lea,
2048 .ops = (Mir.Ops{
2049 .reg1 = addr_reg.to64(),
2050 .reg2 = .rbp,
2051 }).encode(),
2052 .data = .{ .imm = @bitCast(u32, -off) },
2053 });
2054 },
2055 .stack_offset => |off| {
2056 // lea reg, [rbp]
2057 _ = try self.addInst(.{
2058 .tag = .lea,
2059 .ops = (Mir.Ops{
2060 .reg1 = addr_reg.to64(),
2061 .reg2 = .rbp,
2062 }).encode(),
2063 .data = .{ .imm = @bitCast(u32, -off) },
2064 });
2065 },
2066 .memory,
2067 .got_load,
2068 .direct_load,
2069 => {
2070 try self.loadMemPtrIntoRegister(addr_reg, Type.usize, array);
2071 },
2072 else => return self.fail("TODO implement array_elem_val when array is {}", .{array}),
2073 }
20522074
20532075 // TODO we could allocate register here, but need to expect addr register and potentially
20542076 // offset register.
......@@ -2148,11 +2170,11 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
21482170 defer operand.unfreezeIfRegister(&self.register_manager);
21492171
21502172 const tag_abi_size = tag_ty.abiSize(self.target.*);
2151 const offset: i32 = if (layout.tag_align < layout.payload_align) @intCast(i32, layout.payload_size) else 0;
21522173 const dst_mcv: MCValue = blk: {
21532174 switch (operand) {
21542175 .stack_offset => |off| {
21552176 if (tag_abi_size <= 8) {
2177 const offset: i32 = if (layout.tag_align < layout.payload_align) @intCast(i32, layout.payload_size) else 0;
21562178 break :blk try self.copyToRegisterWithInstTracking(inst, tag_ty, .{
21572179 .stack_offset = off - offset,
21582180 });
......@@ -2160,6 +2182,17 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
21602182
21612183 return self.fail("TODO implement get_union_tag for ABI larger than 8 bytes and operand {}", .{operand});
21622184 },
2185 .register => {
2186 const shift: u6 = if (layout.tag_align < layout.payload_align)
2187 @intCast(u6, layout.payload_size * 8)
2188 else
2189 0;
2190 const result = try self.copyToRegisterWithInstTracking(inst, union_ty, operand);
2191 try self.shiftRegister(result.register.to64(), shift);
2192 break :blk MCValue{
2193 .register = registerAlias(result.register, @intCast(u32, layout.tag_size)),
2194 };
2195 },
21632196 else => return self.fail("TODO implement get_union_tag for {}", .{operand}),
21642197 }
21652198 };
......@@ -2354,7 +2387,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
23542387 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
23552388}
23562389
2357fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Register {
2390fn loadMemPtrIntoRegister(self: *Self, reg: Register, ptr_ty: Type, ptr: MCValue) InnerError!void {
23582391 switch (ptr) {
23592392 .got_load,
23602393 .direct_load,
......@@ -2364,11 +2397,10 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re
23642397 .direct_load => 0b01,
23652398 else => unreachable,
23662399 };
2367 const reg = try self.register_manager.allocReg(null);
23682400 _ = try self.addInst(.{
23692401 .tag = .lea_pie,
23702402 .ops = (Mir.Ops{
2371 .reg1 = reg.to64(),
2403 .reg1 = registerAlias(reg, @intCast(u32, ptr_ty.abiSize(self.target.*))),
23722404 .flags = flags,
23732405 }).encode(),
23742406 .data = .{
......@@ -2378,13 +2410,11 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re
23782410 },
23792411 },
23802412 });
2381 return reg.to64();
23822413 },
23832414 .memory => |addr| {
23842415 // TODO: in case the address fits in an imm32 we can use [ds:imm32]
23852416 // instead of wasting an instruction copying the address to a register
2386 const reg = try self.copyToTmpRegister(ptr_ty, .{ .immediate = addr });
2387 return reg.to64();
2417 try self.genSetReg(ptr_ty, reg, .{ .immediate = addr });
23882418 },
23892419 else => unreachable,
23902420 }
......@@ -2484,7 +2514,11 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
24842514 .data = .{ .imm = 0 },
24852515 });
24862516 },
2487 .stack_offset => {
2517 .got_load,
2518 .direct_load,
2519 .memory,
2520 .stack_offset,
2521 => {
24882522 if (abi_size <= 8) {
24892523 const tmp_reg = try self.copyToTmpRegister(value_ty, value);
24902524 return self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);
......@@ -2507,7 +2541,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
25072541 value.freezeIfRegister(&self.register_manager);
25082542 defer value.unfreezeIfRegister(&self.register_manager);
25092543
2510 const addr_reg = try self.loadMemPtrIntoRegister(ptr_ty, ptr);
2544 const addr_reg = try self.register_manager.allocReg(null);
2545 try self.loadMemPtrIntoRegister(addr_reg, ptr_ty, ptr);
25112546
25122547 // to get the actual address of the value we want to modify we have to go through the GOT
25132548 // mov reg, [reg]
......@@ -2686,27 +2721,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
26862721 };
26872722
26882723 // Shift by struct_field_offset.
2689 const shift_amount = @intCast(u8, struct_field_offset * 8);
2690 if (shift_amount > 0) {
2691 if (shift_amount == 1) {
2692 _ = try self.addInst(.{
2693 .tag = .shr,
2694 .ops = (Mir.Ops{
2695 .reg1 = dst_mcv.register,
2696 }).encode(),
2697 .data = undefined,
2698 });
2699 } else {
2700 _ = try self.addInst(.{
2701 .tag = .shr,
2702 .ops = (Mir.Ops{
2703 .reg1 = dst_mcv.register,
2704 .flags = 0b10,
2705 }).encode(),
2706 .data = .{ .imm = shift_amount },
2707 });
2708 }
2709 }
2724 const shift = @intCast(u8, struct_field_offset * 8);
2725 try self.shiftRegister(dst_mcv.register, shift);
27102726
27112727 // Mask with reg.size() - struct_field_size
27122728 const mask_shift = @intCast(u6, (64 - struct_field_ty.bitSize(self.target.*)));
......@@ -3167,11 +3183,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index) !void {
31673183 const ret_abi_align = @intCast(u32, ret_ty.abiAlignment(self.target.*));
31683184 const stack_offset = @intCast(i32, try self.allocMem(inst, ret_abi_size, ret_abi_align));
31693185
3170 try self.register_manager.getReg(.rdi, inst);
3186 try self.register_manager.getReg(.rdi, null);
3187 self.register_manager.freezeRegs(&.{.rdi});
31713188 try self.genSetReg(Type.usize, .rdi, .{ .ptr_stack_offset = stack_offset });
31723189
31733190 info.return_value.stack_offset = stack_offset;
31743191 }
3192 defer if (info.return_value == .stack_offset) self.register_manager.unfreezeRegs(&.{.rdi});
31753193
31763194 for (args) |arg, arg_i| {
31773195 const mc_arg = info.args[arg_i];
......@@ -4676,43 +4694,38 @@ fn genInlineMemcpy(self: *Self, stack_offset: i32, ty: Type, val: MCValue, opts:
46764694 if (opts.dest_stack_base) |reg| self.register_manager.freezeRegs(&.{reg});
46774695 defer if (opts.dest_stack_base) |reg| self.register_manager.unfreezeRegs(&.{reg});
46784696
4679 const addr_reg: Register = blk: {
4680 switch (val) {
4681 .memory,
4682 .direct_load,
4683 .got_load,
4684 => {
4685 break :blk try self.loadMemPtrIntoRegister(Type.usize, val);
4686 },
4687 .ptr_stack_offset, .stack_offset => |off| {
4688 const addr_reg = (try self.register_manager.allocReg(null)).to64();
4689 _ = try self.addInst(.{
4690 .tag = .lea,
4691 .ops = (Mir.Ops{
4692 .reg1 = addr_reg,
4693 .reg2 = opts.source_stack_base orelse .rbp,
4694 }).encode(),
4695 .data = .{ .imm = @bitCast(u32, -off) },
4696 });
4697 break :blk addr_reg;
4698 },
4699 .register => |reg| {
4700 const addr_reg = try self.register_manager.allocReg(null);
4701 _ = try self.addInst(.{
4702 .tag = .mov,
4703 .ops = (Mir.Ops{
4704 .reg1 = registerAlias(addr_reg, @divExact(reg.size(), 8)),
4705 .reg2 = reg,
4706 }).encode(),
4707 .data = undefined,
4708 });
4709 break :blk addr_reg.to64();
4710 },
4711 else => {
4712 return self.fail("TODO implement memcpy for setting stack from {}", .{val});
4713 },
4714 }
4715 };
4697 const addr_reg = try self.register_manager.allocReg(null);
4698 switch (val) {
4699 .memory,
4700 .direct_load,
4701 .got_load,
4702 => {
4703 try self.loadMemPtrIntoRegister(addr_reg, Type.usize, val);
4704 },
4705 .ptr_stack_offset, .stack_offset => |off| {
4706 _ = try self.addInst(.{
4707 .tag = .lea,
4708 .ops = (Mir.Ops{
4709 .reg1 = addr_reg.to64(),
4710 .reg2 = opts.source_stack_base orelse .rbp,
4711 }).encode(),
4712 .data = .{ .imm = @bitCast(u32, -off) },
4713 });
4714 },
4715 .register => |reg| {
4716 _ = try self.addInst(.{
4717 .tag = .mov,
4718 .ops = (Mir.Ops{
4719 .reg1 = registerAlias(addr_reg, @divExact(reg.size(), 8)),
4720 .reg2 = reg,
4721 }).encode(),
4722 .data = undefined,
4723 });
4724 },
4725 else => {
4726 return self.fail("TODO implement memcpy for setting stack from {}", .{val});
4727 },
4728 }
47164729
47174730 self.register_manager.freezeRegs(&.{addr_reg});
47184731 defer self.register_manager.unfreezeRegs(&.{addr_reg});
......@@ -4826,10 +4839,6 @@ fn genInlineMemset(
48264839 try self.register_manager.getReg(.rax, null);
48274840
48284841 const abi_size = ty.abiSize(self.target.*);
4829 if (stack_offset > 128) {
4830 return self.fail("TODO inline memset with large stack offset", .{});
4831 }
4832
48334842 const negative_offset = @bitCast(u32, -stack_offset);
48344843
48354844 // We are actually counting `abi_size` bytes; however, we reuse the index register
......@@ -5768,3 +5777,25 @@ fn registerAlias(reg: Register, size_bytes: u32) Register {
57685777 unreachable; // TODO handle floating-point registers
57695778 }
57705779}
5780
5781fn shiftRegister(self: *Self, reg: Register, shift: u8) !void {
5782 if (shift == 0) return;
5783 if (shift == 1) {
5784 _ = try self.addInst(.{
5785 .tag = .shr,
5786 .ops = (Mir.Ops{
5787 .reg1 = reg,
5788 }).encode(),
5789 .data = undefined,
5790 });
5791 } else {
5792 _ = try self.addInst(.{
5793 .tag = .shr,
5794 .ops = (Mir.Ops{
5795 .reg1 = reg,
5796 .flags = 0b10,
5797 }).encode(),
5798 .data = .{ .imm = shift },
5799 });
5800 }
5801}
src/codegen.zig+18-27
......@@ -553,31 +553,21 @@ pub fn generateSymbol(
553553 const target = bin_file.options.target;
554554 const abi_align = typed_value.ty.abiAlignment(target);
555555
556 {
557 const error_val = if (!is_payload) typed_value.val else Value.initTag(.zero);
558 const begin = code.items.len;
559 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{
560 .ty = error_ty,
561 .val = error_val,
562 }, code, debug_output)) {
563 .appended => {},
564 .externally_managed => |external_slice| {
565 code.appendSliceAssumeCapacity(external_slice);
566 },
567 .fail => |em| return Result{ .fail = em },
568 }
569 const unpadded_end = code.items.len - begin;
570 const padded_end = mem.alignForwardGeneric(u64, unpadded_end, abi_align);
571 const padding = try math.cast(usize, padded_end - unpadded_end);
572
573 if (padding > 0) {
574 try code.writer().writeByteNTimes(0, padding);
575 }
556 const error_val = if (!is_payload) typed_value.val else Value.initTag(.zero);
557 const begin = code.items.len;
558 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{
559 .ty = error_ty,
560 .val = error_val,
561 }, code, debug_output)) {
562 .appended => {},
563 .externally_managed => |external_slice| {
564 code.appendSliceAssumeCapacity(external_slice);
565 },
566 .fail => |em| return Result{ .fail = em },
576567 }
577568
578569 if (payload_ty.hasRuntimeBits()) {
579570 const payload_val = if (typed_value.val.castTag(.eu_payload)) |val| val.data else Value.initTag(.undef);
580 const begin = code.items.len;
581571 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{
582572 .ty = payload_ty,
583573 .val = payload_val,
......@@ -588,13 +578,14 @@ pub fn generateSymbol(
588578 },
589579 .fail => |em| return Result{ .fail = em },
590580 }
591 const unpadded_end = code.items.len - begin;
592 const padded_end = mem.alignForwardGeneric(u64, unpadded_end, abi_align);
593 const padding = try math.cast(usize, padded_end - unpadded_end);
581 }
594582
595 if (padding > 0) {
596 try code.writer().writeByteNTimes(0, padding);
597 }
583 const unpadded_end = code.items.len - begin;
584 const padded_end = mem.alignForwardGeneric(u64, unpadded_end, abi_align);
585 const padding = try math.cast(usize, padded_end - unpadded_end);
586
587 if (padding > 0) {
588 try code.writer().writeByteNTimes(0, padding);
598589 }
599590
600591 return Result{ .appended = {} };
test/behavior/align.zig+3-2
......@@ -131,7 +131,7 @@ fn testBytesAlign(b: u8) !void {
131131test "@alignCast slices" {
132132 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
133133 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
134 if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
134 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
135135
136136 var array align(4) = [_]u32{ 1, 1 };
137137 const slice = array[0..];
......@@ -147,7 +147,8 @@ fn sliceExpects4(slice: []align(4) u32) void {
147147
148148test "return error union with 128-bit integer" {
149149 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
150 if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
150 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
151 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
151152
152153 try expect(3 == try give());
153154}
test/behavior/alignof.zig-2
......@@ -14,7 +14,6 @@ test "@alignOf(T) before referencing T" {
1414 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
1616 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1817 comptime try expect(@alignOf(Foo) != maxInt(usize));
1918 if (native_arch == .x86_64) {
2019 comptime try expect(@alignOf(Foo) == 4);
......@@ -23,7 +22,6 @@ test "@alignOf(T) before referencing T" {
2322
2423test "comparison of @alignOf(T) against zero" {
2524 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
26 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2725 {
2826 const T = struct { x: u32 };
2927 try expect(!(@alignOf(T) == 0));
test/behavior/array.zig-1
......@@ -349,7 +349,6 @@ test "array literal as argument to function" {
349349test "double nested array to const slice cast in array literal" {
350350 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
351351 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
352 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
353352 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
354353
355354 const S = struct {
test/behavior/basic.zig-2
......@@ -287,7 +287,6 @@ fn fB() []const u8 {
287287test "call function pointer in struct" {
288288 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
289289 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
290 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
291290 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
292291
293292 try expect(mem.eql(u8, f3(true), "a"));
......@@ -814,7 +813,6 @@ test "if expression type coercion" {
814813}
815814
816815test "discarding the result of various expressions" {
817 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
818816 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
819817 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
820818
test/behavior/bitcast.zig-3
......@@ -167,7 +167,6 @@ test "@bitCast packed structs at runtime and comptime" {
167167test "@bitCast extern structs at runtime and comptime" {
168168 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
169169 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
170 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
171170 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
172171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
173172
......@@ -241,7 +240,6 @@ test "implicit cast to error union by returning" {
241240test "bitcast packed struct literal to byte" {
242241 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
243242 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
244 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
245243 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
246244
247245 const Foo = packed struct {
......@@ -254,7 +252,6 @@ test "bitcast packed struct literal to byte" {
254252test "comptime bitcast used in expression has the correct type" {
255253 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
256254 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
257 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
258255 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259256
260257 const Foo = packed struct {
test/behavior/bitreverse.zig-1
......@@ -6,7 +6,6 @@ const minInt = std.math.minInt;
66test "@bitReverse large exotic integer" {
77 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
109 // Currently failing on stage1 for big-endian targets
1110 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
1211
test/behavior/bugs/1381.zig-1
......@@ -14,7 +14,6 @@ const A = union(enum) {
1414test "union that needs padding bytes inside an array" {
1515 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1616 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1817 var as = [_]A{
1918 A{ .B = B{ .D = 1 } },
2019 A{ .B = B{ .D = 1 } },
test/behavior/bugs/1735.zig-1
......@@ -45,7 +45,6 @@ test "initialization" {
4545 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4646 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
4747 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
48 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
4948 var t = a.init();
5049 try std.testing.expect(t.foo.len == 0);
5150}
test/behavior/bugs/4954.zig-1
......@@ -5,7 +5,6 @@ fn f(buf: []u8) void {
55}
66
77test "crash" {
8 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
98 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1110
test/behavior/cast.zig+1-20
......@@ -223,7 +223,7 @@ test "@intToEnum passed a comptime_int to an enum with one item" {
223223}
224224
225225test "@intCast to u0 and use the result" {
226 if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
226 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
227227
228228 const S = struct {
229229 fn doTheTest(zero: u1, one: u1, bigzero: i32) !void {
......@@ -324,7 +324,6 @@ test "cast from ?[*]T to ??[*]T" {
324324test "peer type unsigned int to signed" {
325325 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
326326 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
327 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
328327
329328 var w: u31 = 5;
330329 var x: u8 = 7;
......@@ -401,7 +400,6 @@ test "implicitly cast from [0]T to anyerror![]T" {
401400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
402401 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
403402 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
404 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
405403
406404 try testCastZeroArrayToErrSliceMut();
407405 comptime try testCastZeroArrayToErrSliceMut();
......@@ -419,7 +417,6 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
419417 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
420418 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
421419 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
422 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
423420
424421 const S = struct {
425422 fn doTheTest() anyerror!void {
......@@ -475,7 +472,6 @@ fn testCastConstArrayRefToConstSlice() !void {
475472test "peer type resolution: error and [N]T" {
476473 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
477474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
478 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
479475
480476 try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
481477 comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
......@@ -790,7 +786,6 @@ test "peer cast *[0]T to []const T" {
790786test "peer cast *[N]T to [*]T" {
791787 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
792788 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
793 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
794789
795790 var array = [4:99]i32{ 1, 2, 3, 4 };
796791 var dest: [*]i32 = undefined;
......@@ -844,7 +839,6 @@ test "peer cast [N:x]T to [N]T" {
844839 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
845840 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
846841 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
847 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
848842
849843 const S = struct {
850844 fn doTheTest() !void {
......@@ -861,7 +855,6 @@ test "peer cast *[N:x]T to *[N]T" {
861855 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
862856 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
863857 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
864 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
865858
866859 const S = struct {
867860 fn doTheTest() !void {
......@@ -915,7 +908,6 @@ test "peer type resolution implicit cast to return type" {
915908 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
916909 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
917910 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
918 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
919911
920912 const S = struct {
921913 fn doTheTest() !void {
......@@ -1030,7 +1022,6 @@ test "pointer reinterpret const float to int" {
10301022 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10311023 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
10321024 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1033 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10341025
10351026 // The hex representation is 0x3fe3333333333303.
10361027 const float: f64 = 5.99999999999994648725e-01;
......@@ -1116,7 +1107,6 @@ test "peer type resolution: [0]u8 and []const u8" {
11161107 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11171108 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
11181109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1119 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11201110
11211111 try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
11221112 try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
......@@ -1204,7 +1194,6 @@ test "implicit cast *[0]T to E![]const u8" {
12041194 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12051195 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
12061196 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1207 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12081197
12091198 var x = @as(anyerror![]const u8, &[0]u8{});
12101199 try expect((x catch unreachable).len == 0);
......@@ -1212,14 +1201,11 @@ test "implicit cast *[0]T to E![]const u8" {
12121201
12131202var global_array: [4]u8 = undefined;
12141203test "cast from array reference to fn: comptime fn ptr" {
1215 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1216
12171204 const f = @ptrCast(*const fn () callconv(.C) void, &global_array);
12181205 try expect(@ptrToInt(f) == @ptrToInt(&global_array));
12191206}
12201207test "cast from array reference to fn: runtime fn ptr" {
12211208 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1222 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12231209
12241210 var f = @ptrCast(*const fn () callconv(.C) void, &global_array);
12251211 try expect(@ptrToInt(f) == @ptrToInt(&global_array));
......@@ -1243,8 +1229,6 @@ test "*const [N]null u8 to ?[]const u8" {
12431229}
12441230
12451231test "cast between [*c]T and ?[*:0]T on fn parameter" {
1246 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1247
12481232 const S = struct {
12491233 const Handler = ?fn ([*c]const u8) callconv(.C) void;
12501234 fn addCallback(handler: Handler) void {
......@@ -1276,7 +1260,6 @@ test "assignment to optional pointer result loc" {
12761260test "cast between *[N]void and []void" {
12771261 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12781262 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1279 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12801263
12811264 var a: [4]void = undefined;
12821265 var b: []void = &a;
......@@ -1286,7 +1269,6 @@ test "cast between *[N]void and []void" {
12861269test "peer resolve arrays of different size to const slice" {
12871270 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12881271 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1289 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12901272
12911273 try expect(mem.eql(u8, boolToStr(true), "true"));
12921274 try expect(mem.eql(u8, boolToStr(false), "false"));
......@@ -1357,7 +1339,6 @@ test "peer type resolution: unreachable, null, slice" {
13571339test "cast i8 fn call peers to i32 result" {
13581340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13591341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1360 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
13611342
13621343 const S = struct {
13631344 fn doTheTest() !void {
test/behavior/defer.zig-1
......@@ -95,7 +95,6 @@ fn runSomeErrorDefers(x: bool) !bool {
9595}
9696
9797test "mixing normal and error defers" {
98 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9998 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10099 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101100
test/behavior/enum.zig-6
......@@ -616,7 +616,6 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
616616}
617617
618618test "enum with specified tag values" {
619 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
620619 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
621620 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
622621
......@@ -625,7 +624,6 @@ test "enum with specified tag values" {
625624}
626625
627626test "non-exhaustive enum" {
628 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
629627 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
630628 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
631629
......@@ -691,7 +689,6 @@ test "empty non-exhaustive enum" {
691689}
692690
693691test "single field non-exhaustive enum" {
694 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
695692 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
696693 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
697694
......@@ -760,7 +757,6 @@ test "cast integer literal to enum" {
760757}
761758
762759test "enum with specified and unspecified tag values" {
763 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
764760 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
765761 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
766762
......@@ -942,7 +938,6 @@ test "enum value allocation" {
942938}
943939
944940test "enum literal casting to tagged union" {
945 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
946941 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
947942 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
948943
......@@ -968,7 +963,6 @@ test "enum literal casting to tagged union" {
968963const Bar = enum { A, B, C, D };
969964
970965test "enum literal casting to error union with payload enum" {
971 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
972966 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
973967 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
974968
test/behavior/error.zig-9
......@@ -23,7 +23,6 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
2323}
2424
2525test "error binary operator" {
26 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2726 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2827 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2928
......@@ -58,7 +57,6 @@ pub fn baz() anyerror!i32 {
5857}
5958
6059test "error wrapping" {
61 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
6260 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6361 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6462
......@@ -66,7 +64,6 @@ test "error wrapping" {
6664}
6765
6866test "unwrap simple value from error" {
69 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
7067 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7269
......@@ -78,7 +75,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
7875}
7976
8077test "error return in assignment" {
81 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
8278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8379 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8480
......@@ -103,7 +99,6 @@ test "syntax: optional operator in front of error union operator" {
10399}
104100
105101test "widen cast integer payload of error union function call" {
106 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
107102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
108103 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109104
......@@ -121,7 +116,6 @@ test "widen cast integer payload of error union function call" {
121116}
122117
123118test "debug info for optional error set" {
124 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
125119 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
126120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127121
......@@ -173,7 +167,6 @@ fn bar2() (error{}!void) {}
173167test "error union type " {
174168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
175169 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
176 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
177170 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
178171
179172 try testErrorUnionType();
......@@ -191,7 +184,6 @@ fn testErrorUnionType() !void {
191184test "error set type" {
192185 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
193186 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
194 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
195187 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
196188
197189 try testErrorSetType();
......@@ -312,7 +304,6 @@ test "error: Infer error set from literals" {
312304 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313305 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
314306 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
316307 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
317308
318309 _ = nullLiteral("n") catch |err| handleErrors(err);
test/behavior/fn.zig-1
......@@ -216,7 +216,6 @@ fn addPointCoords(pt: Point) i32 {
216216}
217217
218218test "pass by non-copying value through var arg" {
219 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220219 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221220 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
222221
test/behavior/if.zig-1
......@@ -48,7 +48,6 @@ var global_with_val: anyerror!u32 = 0;
4848var global_with_err: anyerror!u32 = error.SomeError;
4949
5050test "unwrap mutable global var" {
51 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
5251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5352 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5453
test/behavior/ir_block_deps.zig-1
......@@ -20,7 +20,6 @@ fn getErrInt() anyerror!i32 {
2020test "ir block deps" {
2121 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2222 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2423
2524 try expect((foo(1) catch unreachable) == 0);
2625 try expect((foo(2) catch unreachable) == 0);
test/behavior/namespace_depends_on_compile_var.zig-1
......@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44
55test "namespace depends on compile var" {
66 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
87 if (some_namespace.a_bool) {
98 try expect(some_namespace.a_bool);
109 } else {
test/behavior/optional.zig-3
......@@ -28,7 +28,6 @@ pub const EmptyStruct = struct {};
2828test "optional pointer to size zero struct" {
2929 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3030 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
3231
3332 var e = EmptyStruct{};
3433 var o: ?*EmptyStruct = &e;
......@@ -37,7 +36,6 @@ test "optional pointer to size zero struct" {
3736
3837test "equality compare optional pointers" {
3938 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4139
4240 try testNullPtrsEql();
4341 comptime try testNullPtrsEql();
......@@ -152,7 +150,6 @@ fn test_cmp_optional_non_optional() !void {
152150test "unwrap function call with optional pointer return value" {
153151 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
154152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
156153
157154 const S = struct {
158155 fn entry() !void {
test/behavior/struct.zig-1
......@@ -247,7 +247,6 @@ test "usingnamespace within struct scope" {
247247
248248test "struct field init with catch" {
249249 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
250 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
251250 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
252251
253252 const S = struct {
test/behavior/try.zig-1
......@@ -3,7 +3,6 @@ const builtin = @import("builtin");
33const expect = std.testing.expect;
44
55test "try on error union" {
6 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
76 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98
test/behavior/underscore.zig-1
......@@ -7,7 +7,6 @@ test "ignore lval with underscore" {
77}
88
99test "ignore lval with underscore (while loop)" {
10 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1110 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1211 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1312
test/behavior/union.zig-7
......@@ -272,7 +272,6 @@ const TheUnion = union(TheTag) {
272272 C: i32,
273273};
274274test "cast union to tag type of union" {
275 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
276275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
277276 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
278277
......@@ -292,7 +291,6 @@ test "union field access gives the enum values" {
292291}
293292
294293test "cast tag type of union to union" {
295 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
296294 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
297295 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
298296
......@@ -307,7 +305,6 @@ const Value2 = union(Letter2) {
307305};
308306
309307test "implicit cast union to its tag type" {
310 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
311308 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
312309 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313310
......@@ -401,7 +398,6 @@ test "tagged union with no payloads" {
401398}
402399
403400test "union with only 1 field casted to its enum type" {
404 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
405401 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
406402 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
407403
......@@ -471,7 +467,6 @@ test "initialize global array of union" {
471467}
472468
473469test "update the tag value for zero-sized unions" {
474 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
475470 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
476471 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
477472
......@@ -707,7 +702,6 @@ test "union with only 1 field casted to its enum type which has enum value speci
707702}
708703
709704test "@enumToInt works on unions" {
710 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
711705 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
712706 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
713707
......@@ -841,7 +835,6 @@ test "@unionInit can modify a union type" {
841835}
842836
843837test "@unionInit can modify a pointer value" {
844 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
845838 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
846839 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
847840
test/behavior/while.zig-4
......@@ -175,7 +175,6 @@ test "while with optional as condition with else" {
175175}
176176
177177test "while with error union condition" {
178 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
179178 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
180179 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
181180
......@@ -248,7 +247,6 @@ fn returnTrue() bool {
248247}
249248
250249test "return with implicit cast from while loop" {
251 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
252250 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
253251
254252 returnWithImplicitCastFromWhileLoopTest() catch unreachable;
......@@ -260,7 +258,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
260258}
261259
262260test "while on error union with else result follow else prong" {
263 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
264261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
265262 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
266263
......@@ -271,7 +268,6 @@ test "while on error union with else result follow else prong" {
271268}
272269
273270test "while on error union with else result follow break prong" {
274 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
275271 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
276272 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277273