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 {...@@ -1738,14 +1738,22 @@ fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
1738 return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });1738 return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
1739 }1739 }
1740 const err_union_ty = self.air.typeOf(ty_op.operand);1740 const err_union_ty = self.air.typeOf(ty_op.operand);
1741 const err_ty = err_union_ty.errorUnionSet();
1741 const payload_ty = err_union_ty.errorUnionPayload();1742 const payload_ty = err_union_ty.errorUnionPayload();
1742 const operand = try self.resolveInst(ty_op.operand);1743 const operand = try self.resolveInst(ty_op.operand);
1744 operand.freezeIfRegister(&self.register_manager);
1745 defer operand.unfreezeIfRegister(&self.register_manager);
1746
1743 const result: MCValue = result: {1747 const result: MCValue = result: {
1744 if (!payload_ty.hasRuntimeBits()) break :result operand;1748 if (!payload_ty.hasRuntimeBits()) break :result operand;
1745 switch (operand) {1749 switch (operand) {
1746 .stack_offset => |off| {1750 .stack_offset => |off| {
1747 break :result MCValue{ .stack_offset = off };1751 break :result MCValue{ .stack_offset = off };
1748 },1752 },
1753 .register => {
1754 // TODO reuse operand
1755 break :result try self.copyToRegisterWithInstTracking(inst, err_ty, operand);
1756 },
1749 else => return self.fail("TODO implement unwrap_err_err for {}", .{operand}),1757 else => return self.fail("TODO implement unwrap_err_err for {}", .{operand}),
1750 }1758 }
1751 };1759 };
...@@ -1763,13 +1771,25 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {...@@ -1763,13 +1771,25 @@ fn airUnwrapErrPayload(self: *Self, inst: Air.Inst.Index) !void {
1763 if (!payload_ty.hasRuntimeBits()) break :result MCValue.none;1771 if (!payload_ty.hasRuntimeBits()) break :result MCValue.none;
17641772
1765 const operand = try self.resolveInst(ty_op.operand);1773 const operand = try self.resolveInst(ty_op.operand);
1774 operand.freezeIfRegister(&self.register_manager);
1775 defer operand.unfreezeIfRegister(&self.register_manager);
1776
1766 const err_ty = err_union_ty.errorUnionSet();1777 const err_ty = err_union_ty.errorUnionSet();
1767 const err_abi_size = @intCast(u32, err_ty.abiSize(self.target.*));
1768 switch (operand) {1778 switch (operand) {
1769 .stack_offset => |off| {1779 .stack_offset => |off| {
1780 const err_abi_size = @intCast(u32, err_ty.abiSize(self.target.*));
1770 const offset = off - @intCast(i32, err_abi_size);1781 const offset = off - @intCast(i32, err_abi_size);
1771 break :result MCValue{ .stack_offset = offset };1782 break :result MCValue{ .stack_offset = offset };
1772 },1783 },
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 },
1773 else => return self.fail("TODO implement unwrap_err_payload for {}", .{operand}),1793 else => return self.fail("TODO implement unwrap_err_payload for {}", .{operand}),
1774 }1794 }
1775 };1795 };
...@@ -2013,42 +2033,44 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -2013,42 +2033,44 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
2013 self.register_manager.freezeRegs(&.{offset_reg});2033 self.register_manager.freezeRegs(&.{offset_reg});
2014 defer self.register_manager.unfreezeRegs(&.{offset_reg});2034 defer self.register_manager.unfreezeRegs(&.{offset_reg});
20152035
2016 const addr_reg = blk: {2036 const addr_reg = try self.register_manager.allocReg(null);
2017 const off = inner: {2037 switch (array) {
2018 switch (array) {2038 .register => {
2019 .register => {2039 const off = @intCast(i32, try self.allocMem(
2020 const off = @intCast(i32, try self.allocMem(2040 inst,
2021 inst,2041 @intCast(u32, array_ty.abiSize(self.target.*)),
2022 @intCast(u32, array_ty.abiSize(self.target.*)),2042 array_ty.abiAlignment(self.target.*),
2023 array_ty.abiAlignment(self.target.*),2043 ));
2024 ));2044 try self.genSetStack(array_ty, off, array, .{});
2025 try self.genSetStack(array_ty, off, array, .{});2045 // lea reg, [rbp]
2026 break :inner off;2046 _ = try self.addInst(.{
2027 },2047 .tag = .lea,
2028 .stack_offset => |off| {2048 .ops = (Mir.Ops{
2029 break :inner off;2049 .reg1 = addr_reg.to64(),
2030 },2050 .reg2 = .rbp,
2031 .memory,2051 }).encode(),
2032 .got_load,2052 .data = .{ .imm = @bitCast(u32, -off) },
2033 .direct_load,2053 });
2034 => {2054 },
2035 break :blk try self.loadMemPtrIntoRegister(Type.usize, array);2055 .stack_offset => |off| {
2036 },2056 // lea reg, [rbp]
2037 else => return self.fail("TODO implement array_elem_val when array is {}", .{array}),2057 _ = try self.addInst(.{
2038 }2058 .tag = .lea,
2039 };2059 .ops = (Mir.Ops{
2040 const addr_reg = try self.register_manager.allocReg(null);2060 .reg1 = addr_reg.to64(),
2041 // lea reg, [rbp]2061 .reg2 = .rbp,
2042 _ = try self.addInst(.{2062 }).encode(),
2043 .tag = .lea,2063 .data = .{ .imm = @bitCast(u32, -off) },
2044 .ops = (Mir.Ops{2064 });
2045 .reg1 = addr_reg.to64(),2065 },
2046 .reg2 = .rbp,2066 .memory,
2047 }).encode(),2067 .got_load,
2048 .data = .{ .imm = @bitCast(u32, -off) },2068 .direct_load,
2049 });2069 => {
2050 break :blk addr_reg.to64();2070 try self.loadMemPtrIntoRegister(addr_reg, Type.usize, array);
2051 };2071 },
2072 else => return self.fail("TODO implement array_elem_val when array is {}", .{array}),
2073 }
20522074
2053 // TODO we could allocate register here, but need to expect addr register and potentially2075 // TODO we could allocate register here, but need to expect addr register and potentially
2054 // offset register.2076 // offset register.
...@@ -2148,11 +2170,11 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {...@@ -2148,11 +2170,11 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
2148 defer operand.unfreezeIfRegister(&self.register_manager);2170 defer operand.unfreezeIfRegister(&self.register_manager);
21492171
2150 const tag_abi_size = tag_ty.abiSize(self.target.*);2172 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;
2152 const dst_mcv: MCValue = blk: {2173 const dst_mcv: MCValue = blk: {
2153 switch (operand) {2174 switch (operand) {
2154 .stack_offset => |off| {2175 .stack_offset => |off| {
2155 if (tag_abi_size <= 8) {2176 if (tag_abi_size <= 8) {
2177 const offset: i32 = if (layout.tag_align < layout.payload_align) @intCast(i32, layout.payload_size) else 0;
2156 break :blk try self.copyToRegisterWithInstTracking(inst, tag_ty, .{2178 break :blk try self.copyToRegisterWithInstTracking(inst, tag_ty, .{
2157 .stack_offset = off - offset,2179 .stack_offset = off - offset,
2158 });2180 });
...@@ -2160,6 +2182,17 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {...@@ -2160,6 +2182,17 @@ fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
21602182
2161 return self.fail("TODO implement get_union_tag for ABI larger than 8 bytes and operand {}", .{operand});2183 return self.fail("TODO implement get_union_tag for ABI larger than 8 bytes and operand {}", .{operand});
2162 },2184 },
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 },
2163 else => return self.fail("TODO implement get_union_tag for {}", .{operand}),2196 else => return self.fail("TODO implement get_union_tag for {}", .{operand}),
2164 }2197 }
2165 };2198 };
...@@ -2354,7 +2387,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {...@@ -2354,7 +2387,7 @@ fn airLoad(self: *Self, inst: Air.Inst.Index) !void {
2354 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });2387 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2355}2388}
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 {
2358 switch (ptr) {2391 switch (ptr) {
2359 .got_load,2392 .got_load,
2360 .direct_load,2393 .direct_load,
...@@ -2364,11 +2397,10 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re...@@ -2364,11 +2397,10 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re
2364 .direct_load => 0b01,2397 .direct_load => 0b01,
2365 else => unreachable,2398 else => unreachable,
2366 };2399 };
2367 const reg = try self.register_manager.allocReg(null);
2368 _ = try self.addInst(.{2400 _ = try self.addInst(.{
2369 .tag = .lea_pie,2401 .tag = .lea_pie,
2370 .ops = (Mir.Ops{2402 .ops = (Mir.Ops{
2371 .reg1 = reg.to64(),2403 .reg1 = registerAlias(reg, @intCast(u32, ptr_ty.abiSize(self.target.*))),
2372 .flags = flags,2404 .flags = flags,
2373 }).encode(),2405 }).encode(),
2374 .data = .{2406 .data = .{
...@@ -2378,13 +2410,11 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re...@@ -2378,13 +2410,11 @@ fn loadMemPtrIntoRegister(self: *Self, ptr_ty: Type, ptr: MCValue) InnerError!Re
2378 },2410 },
2379 },2411 },
2380 });2412 });
2381 return reg.to64();
2382 },2413 },
2383 .memory => |addr| {2414 .memory => |addr| {
2384 // TODO: in case the address fits in an imm32 we can use [ds:imm32]2415 // TODO: in case the address fits in an imm32 we can use [ds:imm32]
2385 // instead of wasting an instruction copying the address to a register2416 // instead of wasting an instruction copying the address to a register
2386 const reg = try self.copyToTmpRegister(ptr_ty, .{ .immediate = addr });2417 try self.genSetReg(ptr_ty, reg, .{ .immediate = addr });
2387 return reg.to64();
2388 },2418 },
2389 else => unreachable,2419 else => unreachable,
2390 }2420 }
...@@ -2484,7 +2514,11 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type...@@ -2484,7 +2514,11 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2484 .data = .{ .imm = 0 },2514 .data = .{ .imm = 0 },
2485 });2515 });
2486 },2516 },
2487 .stack_offset => {2517 .got_load,
2518 .direct_load,
2519 .memory,
2520 .stack_offset,
2521 => {
2488 if (abi_size <= 8) {2522 if (abi_size <= 8) {
2489 const tmp_reg = try self.copyToTmpRegister(value_ty, value);2523 const tmp_reg = try self.copyToTmpRegister(value_ty, value);
2490 return self.store(ptr, .{ .register = tmp_reg }, ptr_ty, value_ty);2524 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...@@ -2507,7 +2541,8 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
2507 value.freezeIfRegister(&self.register_manager);2541 value.freezeIfRegister(&self.register_manager);
2508 defer value.unfreezeIfRegister(&self.register_manager);2542 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
2512 // to get the actual address of the value we want to modify we have to go through the GOT2547 // to get the actual address of the value we want to modify we have to go through the GOT
2513 // mov reg, [reg]2548 // mov reg, [reg]
...@@ -2686,27 +2721,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {...@@ -2686,27 +2721,8 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
2686 };2721 };
26872722
2688 // Shift by struct_field_offset.2723 // Shift by struct_field_offset.
2689 const shift_amount = @intCast(u8, struct_field_offset * 8);2724 const shift = @intCast(u8, struct_field_offset * 8);
2690 if (shift_amount > 0) {2725 try self.shiftRegister(dst_mcv.register, shift);
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 }
27102726
2711 // Mask with reg.size() - struct_field_size2727 // Mask with reg.size() - struct_field_size
2712 const mask_shift = @intCast(u6, (64 - struct_field_ty.bitSize(self.target.*)));2728 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 {...@@ -3167,11 +3183,13 @@ fn airCall(self: *Self, inst: Air.Inst.Index) !void {
3167 const ret_abi_align = @intCast(u32, ret_ty.abiAlignment(self.target.*));3183 const ret_abi_align = @intCast(u32, ret_ty.abiAlignment(self.target.*));
3168 const stack_offset = @intCast(i32, try self.allocMem(inst, ret_abi_size, ret_abi_align));3184 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});
3171 try self.genSetReg(Type.usize, .rdi, .{ .ptr_stack_offset = stack_offset });3188 try self.genSetReg(Type.usize, .rdi, .{ .ptr_stack_offset = stack_offset });
31723189
3173 info.return_value.stack_offset = stack_offset;3190 info.return_value.stack_offset = stack_offset;
3174 }3191 }
3192 defer if (info.return_value == .stack_offset) self.register_manager.unfreezeRegs(&.{.rdi});
31753193
3176 for (args) |arg, arg_i| {3194 for (args) |arg, arg_i| {
3177 const mc_arg = info.args[arg_i];3195 const mc_arg = info.args[arg_i];
...@@ -4676,43 +4694,38 @@ fn genInlineMemcpy(self: *Self, stack_offset: i32, ty: Type, val: MCValue, opts:...@@ -4676,43 +4694,38 @@ fn genInlineMemcpy(self: *Self, stack_offset: i32, ty: Type, val: MCValue, opts:
4676 if (opts.dest_stack_base) |reg| self.register_manager.freezeRegs(&.{reg});4694 if (opts.dest_stack_base) |reg| self.register_manager.freezeRegs(&.{reg});
4677 defer if (opts.dest_stack_base) |reg| self.register_manager.unfreezeRegs(&.{reg});4695 defer if (opts.dest_stack_base) |reg| self.register_manager.unfreezeRegs(&.{reg});
46784696
4679 const addr_reg: Register = blk: {4697 const addr_reg = try self.register_manager.allocReg(null);
4680 switch (val) {4698 switch (val) {
4681 .memory,4699 .memory,
4682 .direct_load,4700 .direct_load,
4683 .got_load,4701 .got_load,
4684 => {4702 => {
4685 break :blk try self.loadMemPtrIntoRegister(Type.usize, val);4703 try self.loadMemPtrIntoRegister(addr_reg, Type.usize, val);
4686 },4704 },
4687 .ptr_stack_offset, .stack_offset => |off| {4705 .ptr_stack_offset, .stack_offset => |off| {
4688 const addr_reg = (try self.register_manager.allocReg(null)).to64();4706 _ = try self.addInst(.{
4689 _ = try self.addInst(.{4707 .tag = .lea,
4690 .tag = .lea,4708 .ops = (Mir.Ops{
4691 .ops = (Mir.Ops{4709 .reg1 = addr_reg.to64(),
4692 .reg1 = addr_reg,4710 .reg2 = opts.source_stack_base orelse .rbp,
4693 .reg2 = opts.source_stack_base orelse .rbp,4711 }).encode(),
4694 }).encode(),4712 .data = .{ .imm = @bitCast(u32, -off) },
4695 .data = .{ .imm = @bitCast(u32, -off) },4713 });
4696 });4714 },
4697 break :blk addr_reg;4715 .register => |reg| {
4698 },4716 _ = try self.addInst(.{
4699 .register => |reg| {4717 .tag = .mov,
4700 const addr_reg = try self.register_manager.allocReg(null);4718 .ops = (Mir.Ops{
4701 _ = try self.addInst(.{4719 .reg1 = registerAlias(addr_reg, @divExact(reg.size(), 8)),
4702 .tag = .mov,4720 .reg2 = reg,
4703 .ops = (Mir.Ops{4721 }).encode(),
4704 .reg1 = registerAlias(addr_reg, @divExact(reg.size(), 8)),4722 .data = undefined,
4705 .reg2 = reg,4723 });
4706 }).encode(),4724 },
4707 .data = undefined,4725 else => {
4708 });4726 return self.fail("TODO implement memcpy for setting stack from {}", .{val});
4709 break :blk addr_reg.to64();4727 },
4710 },4728 }
4711 else => {
4712 return self.fail("TODO implement memcpy for setting stack from {}", .{val});
4713 },
4714 }
4715 };
47164729
4717 self.register_manager.freezeRegs(&.{addr_reg});4730 self.register_manager.freezeRegs(&.{addr_reg});
4718 defer self.register_manager.unfreezeRegs(&.{addr_reg});4731 defer self.register_manager.unfreezeRegs(&.{addr_reg});
...@@ -4826,10 +4839,6 @@ fn genInlineMemset(...@@ -4826,10 +4839,6 @@ fn genInlineMemset(
4826 try self.register_manager.getReg(.rax, null);4839 try self.register_manager.getReg(.rax, null);
48274840
4828 const abi_size = ty.abiSize(self.target.*);4841 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
4833 const negative_offset = @bitCast(u32, -stack_offset);4842 const negative_offset = @bitCast(u32, -stack_offset);
48344843
4835 // We are actually counting `abi_size` bytes; however, we reuse the index register4844 // 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 {...@@ -5768,3 +5777,25 @@ fn registerAlias(reg: Register, size_bytes: u32) Register {
5768 unreachable; // TODO handle floating-point registers5777 unreachable; // TODO handle floating-point registers
5769 }5778 }
5770}5779}
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(...@@ -553,31 +553,21 @@ pub fn generateSymbol(
553 const target = bin_file.options.target;553 const target = bin_file.options.target;
554 const abi_align = typed_value.ty.abiAlignment(target);554 const abi_align = typed_value.ty.abiAlignment(target);
555555
556 {556 const error_val = if (!is_payload) typed_value.val else Value.initTag(.zero);
557 const error_val = if (!is_payload) typed_value.val else Value.initTag(.zero);557 const begin = code.items.len;
558 const begin = code.items.len;558 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{
559 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{559 .ty = error_ty,
560 .ty = error_ty,560 .val = error_val,
561 .val = error_val,561 }, code, debug_output)) {
562 }, code, debug_output)) {562 .appended => {},
563 .appended => {},563 .externally_managed => |external_slice| {
564 .externally_managed => |external_slice| {564 code.appendSliceAssumeCapacity(external_slice);
565 code.appendSliceAssumeCapacity(external_slice);565 },
566 },566 .fail => |em| return Result{ .fail = em },
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 }
576 }567 }
577568
578 if (payload_ty.hasRuntimeBits()) {569 if (payload_ty.hasRuntimeBits()) {
579 const payload_val = if (typed_value.val.castTag(.eu_payload)) |val| val.data else Value.initTag(.undef);570 const payload_val = if (typed_value.val.castTag(.eu_payload)) |val| val.data else Value.initTag(.undef);
580 const begin = code.items.len;
581 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{571 switch (try generateSymbol(bin_file, parent_atom_index, src_loc, .{
582 .ty = payload_ty,572 .ty = payload_ty,
583 .val = payload_val,573 .val = payload_val,
...@@ -588,13 +578,14 @@ pub fn generateSymbol(...@@ -588,13 +578,14 @@ pub fn generateSymbol(
588 },578 },
589 .fail => |em| return Result{ .fail = em },579 .fail => |em| return Result{ .fail = em },
590 }580 }
591 const unpadded_end = code.items.len - begin;581 }
592 const padded_end = mem.alignForwardGeneric(u64, unpadded_end, abi_align);
593 const padding = try math.cast(usize, padded_end - unpadded_end);
594582
595 if (padding > 0) {583 const unpadded_end = code.items.len - begin;
596 try code.writer().writeByteNTimes(0, padding);584 const padded_end = mem.alignForwardGeneric(u64, unpadded_end, abi_align);
597 }585 const padding = try math.cast(usize, padded_end - unpadded_end);
586
587 if (padding > 0) {
588 try code.writer().writeByteNTimes(0, padding);
598 }589 }
599590
600 return Result{ .appended = {} };591 return Result{ .appended = {} };
test/behavior/align.zig+3-2
...@@ -131,7 +131,7 @@ fn testBytesAlign(b: u8) !void {...@@ -131,7 +131,7 @@ fn testBytesAlign(b: u8) !void {
131test "@alignCast slices" {131test "@alignCast slices" {
132 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;132 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
133 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;133 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
136 var array align(4) = [_]u32{ 1, 1 };136 var array align(4) = [_]u32{ 1, 1 };
137 const slice = array[0..];137 const slice = array[0..];
...@@ -147,7 +147,8 @@ fn sliceExpects4(slice: []align(4) u32) void {...@@ -147,7 +147,8 @@ fn sliceExpects4(slice: []align(4) u32) void {
147147
148test "return error union with 128-bit integer" {148test "return error union with 128-bit integer" {
149 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;149 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
152 try expect(3 == try give());153 try expect(3 == try give());
153}154}
test/behavior/alignof.zig-2
...@@ -14,7 +14,6 @@ test "@alignOf(T) before referencing T" {...@@ -14,7 +14,6 @@ test "@alignOf(T) before referencing T" {
14 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;14 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;15 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
16 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;16 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
18 comptime try expect(@alignOf(Foo) != maxInt(usize));17 comptime try expect(@alignOf(Foo) != maxInt(usize));
19 if (native_arch == .x86_64) {18 if (native_arch == .x86_64) {
20 comptime try expect(@alignOf(Foo) == 4);19 comptime try expect(@alignOf(Foo) == 4);
...@@ -23,7 +22,6 @@ test "@alignOf(T) before referencing T" {...@@ -23,7 +22,6 @@ test "@alignOf(T) before referencing T" {
2322
24test "comparison of @alignOf(T) against zero" {23test "comparison of @alignOf(T) against zero" {
25 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;24 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
26 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
27 {25 {
28 const T = struct { x: u32 };26 const T = struct { x: u32 };
29 try expect(!(@alignOf(T) == 0));27 try expect(!(@alignOf(T) == 0));
test/behavior/array.zig-1
...@@ -349,7 +349,6 @@ test "array literal as argument to function" {...@@ -349,7 +349,6 @@ test "array literal as argument to function" {
349test "double nested array to const slice cast in array literal" {349test "double nested array to const slice cast in array literal" {
350 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;350 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
351 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO351 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
352 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
353 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO352 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
354353
355 const S = struct {354 const S = struct {
test/behavior/basic.zig-2
...@@ -287,7 +287,6 @@ fn fB() []const u8 {...@@ -287,7 +287,6 @@ fn fB() []const u8 {
287test "call function pointer in struct" {287test "call function pointer in struct" {
288 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;288 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
289 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;289 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
290 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
291 if (builtin.zig_backend == .stage1) return error.SkipZigTest;290 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
292291
293 try expect(mem.eql(u8, f3(true), "a"));292 try expect(mem.eql(u8, f3(true), "a"));
...@@ -814,7 +813,6 @@ test "if expression type coercion" {...@@ -814,7 +813,6 @@ test "if expression type coercion" {
814}813}
815814
816test "discarding the result of various expressions" {815test "discarding the result of various expressions" {
817 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
818 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO816 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
819 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO817 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" {...@@ -167,7 +167,6 @@ test "@bitCast packed structs at runtime and comptime" {
167test "@bitCast extern structs at runtime and comptime" {167test "@bitCast extern structs at runtime and comptime" {
168 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;168 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
169 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;169 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
170 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
171 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;170 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
173172
...@@ -241,7 +240,6 @@ test "implicit cast to error union by returning" {...@@ -241,7 +240,6 @@ test "implicit cast to error union by returning" {
241test "bitcast packed struct literal to byte" {240test "bitcast packed struct literal to byte" {
242 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;241 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
243 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;242 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
244 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
245 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;243 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
246244
247 const Foo = packed struct {245 const Foo = packed struct {
...@@ -254,7 +252,6 @@ test "bitcast packed struct literal to byte" {...@@ -254,7 +252,6 @@ test "bitcast packed struct literal to byte" {
254test "comptime bitcast used in expression has the correct type" {252test "comptime bitcast used in expression has the correct type" {
255 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;253 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
256 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;254 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
257 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
258 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;255 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
259256
260 const Foo = packed struct {257 const Foo = packed struct {
test/behavior/bitreverse.zig-1
...@@ -6,7 +6,6 @@ const minInt = std.math.minInt;...@@ -6,7 +6,6 @@ const minInt = std.math.minInt;
6test "@bitReverse large exotic integer" {6test "@bitReverse large exotic integer" {
7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;7 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
8 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;8 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
10 // Currently failing on stage1 for big-endian targets9 // Currently failing on stage1 for big-endian targets
11 if (builtin.zig_backend == .stage1) return error.SkipZigTest;10 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
1211
test/behavior/bugs/1381.zig-1
...@@ -14,7 +14,6 @@ const A = union(enum) {...@@ -14,7 +14,6 @@ const A = union(enum) {
14test "union that needs padding bytes inside an array" {14test "union that needs padding bytes inside an array" {
15 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;15 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;16 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
18 var as = [_]A{17 var as = [_]A{
19 A{ .B = B{ .D = 1 } },18 A{ .B = B{ .D = 1 } },
20 A{ .B = B{ .D = 1 } },19 A{ .B = B{ .D = 1 } },
test/behavior/bugs/1735.zig-1
...@@ -45,7 +45,6 @@ test "initialization" {...@@ -45,7 +45,6 @@ test "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_c) return error.SkipZigTest;46 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
47 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;47 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
48 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
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);
51}50}
test/behavior/bugs/4954.zig-1
...@@ -5,7 +5,6 @@ fn f(buf: []u8) void {...@@ -5,7 +5,6 @@ fn f(buf: []u8) void {
5}5}
66
7test "crash" {7test "crash" {
8 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
9 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;9 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" {...@@ -223,7 +223,7 @@ test "@intToEnum passed a comptime_int to an enum with one item" {
223}223}
224224
225test "@intCast to u0 and use the result" {225test "@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
228 const S = struct {228 const S = struct {
229 fn doTheTest(zero: u1, one: u1, bigzero: i32) !void {229 fn doTheTest(zero: u1, one: u1, bigzero: i32) !void {
...@@ -324,7 +324,6 @@ test "cast from ?[*]T to ??[*]T" {...@@ -324,7 +324,6 @@ test "cast from ?[*]T to ??[*]T" {
324test "peer type unsigned int to signed" {324test "peer type unsigned int to signed" {
325 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;325 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
326 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;326 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
327 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
328327
329 var w: u31 = 5;328 var w: u31 = 5;
330 var x: u8 = 7;329 var x: u8 = 7;
...@@ -401,7 +400,6 @@ test "implicitly cast from [0]T to anyerror![]T" {...@@ -401,7 +400,6 @@ test "implicitly cast from [0]T to anyerror![]T" {
401 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
402 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO401 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
403 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO402 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
404 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
405403
406 try testCastZeroArrayToErrSliceMut();404 try testCastZeroArrayToErrSliceMut();
407 comptime try testCastZeroArrayToErrSliceMut();405 comptime try testCastZeroArrayToErrSliceMut();
...@@ -419,7 +417,6 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {...@@ -419,7 +417,6 @@ test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
419 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;417 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
420 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO418 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
421 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO419 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
422 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
423420
424 const S = struct {421 const S = struct {
425 fn doTheTest() anyerror!void {422 fn doTheTest() anyerror!void {
...@@ -475,7 +472,6 @@ fn testCastConstArrayRefToConstSlice() !void {...@@ -475,7 +472,6 @@ fn testCastConstArrayRefToConstSlice() !void {
475test "peer type resolution: error and [N]T" {472test "peer type resolution: error and [N]T" {
476 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;473 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
477 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO474 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
478 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
479475
480 try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));476 try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
481 comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));477 comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
...@@ -790,7 +786,6 @@ test "peer cast *[0]T to []const T" {...@@ -790,7 +786,6 @@ test "peer cast *[0]T to []const T" {
790test "peer cast *[N]T to [*]T" {786test "peer cast *[N]T to [*]T" {
791 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;787 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
792 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO788 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
793 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
794789
795 var array = [4:99]i32{ 1, 2, 3, 4 };790 var array = [4:99]i32{ 1, 2, 3, 4 };
796 var dest: [*]i32 = undefined;791 var dest: [*]i32 = undefined;
...@@ -844,7 +839,6 @@ test "peer cast [N:x]T to [N]T" {...@@ -844,7 +839,6 @@ test "peer cast [N:x]T to [N]T" {
844 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;839 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
845 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO840 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
846 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO841 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
847 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
848842
849 const S = struct {843 const S = struct {
850 fn doTheTest() !void {844 fn doTheTest() !void {
...@@ -861,7 +855,6 @@ test "peer cast *[N:x]T to *[N]T" {...@@ -861,7 +855,6 @@ test "peer cast *[N:x]T to *[N]T" {
861 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;855 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
862 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO856 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
863 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO857 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
864 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
865858
866 const S = struct {859 const S = struct {
867 fn doTheTest() !void {860 fn doTheTest() !void {
...@@ -915,7 +908,6 @@ test "peer type resolution implicit cast to return type" {...@@ -915,7 +908,6 @@ test "peer type resolution implicit cast to return type" {
915 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;908 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
916 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO909 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
917 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO910 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
918 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
919911
920 const S = struct {912 const S = struct {
921 fn doTheTest() !void {913 fn doTheTest() !void {
...@@ -1030,7 +1022,6 @@ test "pointer reinterpret const float to int" {...@@ -1030,7 +1022,6 @@ test "pointer reinterpret const float to int" {
1030 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1022 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1031 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO1023 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1032 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1024 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1033 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10341025
1035 // The hex representation is 0x3fe3333333333303.1026 // The hex representation is 0x3fe3333333333303.
1036 const float: f64 = 5.99999999999994648725e-01;1027 const float: f64 = 5.99999999999994648725e-01;
...@@ -1116,7 +1107,6 @@ test "peer type resolution: [0]u8 and []const u8" {...@@ -1116,7 +1107,6 @@ test "peer type resolution: [0]u8 and []const u8" {
1116 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1107 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1117 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO1108 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1118 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1119 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11201110
1121 try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);1111 try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
1122 try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);1112 try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
...@@ -1204,7 +1194,6 @@ test "implicit cast *[0]T to E![]const u8" {...@@ -1204,7 +1194,6 @@ test "implicit cast *[0]T to E![]const u8" {
1204 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1194 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1205 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO1195 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1206 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1196 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1207 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12081197
1209 var x = @as(anyerror![]const u8, &[0]u8{});1198 var x = @as(anyerror![]const u8, &[0]u8{});
1210 try expect((x catch unreachable).len == 0);1199 try expect((x catch unreachable).len == 0);
...@@ -1212,14 +1201,11 @@ test "implicit cast *[0]T to E![]const u8" {...@@ -1212,14 +1201,11 @@ test "implicit cast *[0]T to E![]const u8" {
12121201
1213var global_array: [4]u8 = undefined;1202var global_array: [4]u8 = undefined;
1214test "cast from array reference to fn: comptime fn ptr" {1203test "cast from array reference to fn: comptime fn ptr" {
1215 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1216
1217 const f = @ptrCast(*const fn () callconv(.C) void, &global_array);1204 const f = @ptrCast(*const fn () callconv(.C) void, &global_array);
1218 try expect(@ptrToInt(f) == @ptrToInt(&global_array));1205 try expect(@ptrToInt(f) == @ptrToInt(&global_array));
1219}1206}
1220test "cast from array reference to fn: runtime fn ptr" {1207test "cast from array reference to fn: runtime fn ptr" {
1221 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO1208 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1222 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12231209
1224 var f = @ptrCast(*const fn () callconv(.C) void, &global_array);1210 var f = @ptrCast(*const fn () callconv(.C) void, &global_array);
1225 try expect(@ptrToInt(f) == @ptrToInt(&global_array));1211 try expect(@ptrToInt(f) == @ptrToInt(&global_array));
...@@ -1243,8 +1229,6 @@ test "*const [N]null u8 to ?[]const u8" {...@@ -1243,8 +1229,6 @@ test "*const [N]null u8 to ?[]const u8" {
1243}1229}
12441230
1245test "cast between [*c]T and ?[*:0]T on fn parameter" {1231test "cast between [*c]T and ?[*:0]T on fn parameter" {
1246 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1247
1248 const S = struct {1232 const S = struct {
1249 const Handler = ?fn ([*c]const u8) callconv(.C) void;1233 const Handler = ?fn ([*c]const u8) callconv(.C) void;
1250 fn addCallback(handler: Handler) void {1234 fn addCallback(handler: Handler) void {
...@@ -1276,7 +1260,6 @@ test "assignment to optional pointer result loc" {...@@ -1276,7 +1260,6 @@ test "assignment to optional pointer result loc" {
1276test "cast between *[N]void and []void" {1260test "cast between *[N]void and []void" {
1277 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1261 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1262 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1279 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12801263
1281 var a: [4]void = undefined;1264 var a: [4]void = undefined;
1282 var b: []void = &a;1265 var b: []void = &a;
...@@ -1286,7 +1269,6 @@ test "cast between *[N]void and []void" {...@@ -1286,7 +1269,6 @@ test "cast between *[N]void and []void" {
1286test "peer resolve arrays of different size to const slice" {1269test "peer resolve arrays of different size to const slice" {
1287 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1270 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1288 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1271 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1289 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12901272
1291 try expect(mem.eql(u8, boolToStr(true), "true"));1273 try expect(mem.eql(u8, boolToStr(true), "true"));
1292 try expect(mem.eql(u8, boolToStr(false), "false"));1274 try expect(mem.eql(u8, boolToStr(false), "false"));
...@@ -1357,7 +1339,6 @@ test "peer type resolution: unreachable, null, slice" {...@@ -1357,7 +1339,6 @@ test "peer type resolution: unreachable, null, slice" {
1357test "cast i8 fn call peers to i32 result" {1339test "cast i8 fn call peers to i32 result" {
1358 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;1340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1359 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO1341 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1360 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
13611342
1362 const S = struct {1343 const S = struct {
1363 fn doTheTest() !void {1344 fn doTheTest() !void {
test/behavior/defer.zig-1
...@@ -95,7 +95,6 @@ fn runSomeErrorDefers(x: bool) !bool {...@@ -95,7 +95,6 @@ fn runSomeErrorDefers(x: bool) !bool {
95}95}
9696
97test "mixing normal and error defers" {97test "mixing normal and error defers" {
98 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
99 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
100 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO99 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 {...@@ -616,7 +616,6 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
616}616}
617617
618test "enum with specified tag values" {618test "enum with specified tag values" {
619 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
620 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;619 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
621 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;620 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
622621
...@@ -625,7 +624,6 @@ test "enum with specified tag values" {...@@ -625,7 +624,6 @@ test "enum with specified tag values" {
625}624}
626625
627test "non-exhaustive enum" {626test "non-exhaustive enum" {
628 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
629 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;627 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
630 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;628 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
631629
...@@ -691,7 +689,6 @@ test "empty non-exhaustive enum" {...@@ -691,7 +689,6 @@ test "empty non-exhaustive enum" {
691}689}
692690
693test "single field non-exhaustive enum" {691test "single field non-exhaustive enum" {
694 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
695 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;692 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
696 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;693 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
697694
...@@ -760,7 +757,6 @@ test "cast integer literal to enum" {...@@ -760,7 +757,6 @@ test "cast integer literal to enum" {
760}757}
761758
762test "enum with specified and unspecified tag values" {759test "enum with specified and unspecified tag values" {
763 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
764 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;760 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
765 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;761 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
766762
...@@ -942,7 +938,6 @@ test "enum value allocation" {...@@ -942,7 +938,6 @@ test "enum value allocation" {
942}938}
943939
944test "enum literal casting to tagged union" {940test "enum literal casting to tagged union" {
945 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
946 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;941 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
947 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;942 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
948943
...@@ -968,7 +963,6 @@ test "enum literal casting to tagged union" {...@@ -968,7 +963,6 @@ test "enum literal casting to tagged union" {
968const Bar = enum { A, B, C, D };963const Bar = enum { A, B, C, D };
969964
970test "enum literal casting to error union with payload enum" {965test "enum literal casting to error union with payload enum" {
971 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
972 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;966 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
973 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;967 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 {...@@ -23,7 +23,6 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
23}23}
2424
25test "error binary operator" {25test "error binary operator" {
26 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
27 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;26 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
28 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;27 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2928
...@@ -58,7 +57,6 @@ pub fn baz() anyerror!i32 {...@@ -58,7 +57,6 @@ pub fn baz() anyerror!i32 {
58}57}
5958
60test "error wrapping" {59test "error wrapping" {
61 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
62 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;60 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
63 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;61 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6462
...@@ -66,7 +64,6 @@ test "error wrapping" {...@@ -66,7 +64,6 @@ test "error wrapping" {
66}64}
6765
68test "unwrap simple value from error" {66test "unwrap simple value from error" {
69 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
70 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;67 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
71 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;68 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7269
...@@ -78,7 +75,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {...@@ -78,7 +75,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
78}75}
7976
80test "error return in assignment" {77test "error return in assignment" {
81 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
82 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;78 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
83 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;79 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8480
...@@ -103,7 +99,6 @@ test "syntax: optional operator in front of error union operator" {...@@ -103,7 +99,6 @@ test "syntax: optional operator in front of error union operator" {
103}99}
104100
105test "widen cast integer payload of error union function call" {101test "widen cast integer payload of error union function call" {
106 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
107 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;102 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
108 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;103 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109104
...@@ -121,7 +116,6 @@ test "widen cast integer payload of error union function call" {...@@ -121,7 +116,6 @@ test "widen cast integer payload of error union function call" {
121}116}
122117
123test "debug info for optional error set" {118test "debug info for optional error set" {
124 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
125 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;119 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
126 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;120 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127121
...@@ -173,7 +167,6 @@ fn bar2() (error{}!void) {}...@@ -173,7 +167,6 @@ fn bar2() (error{}!void) {}
173test "error union type " {167test "error union type " {
174 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
175 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO169 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
176 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
177 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO170 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
178171
179 try testErrorUnionType();172 try testErrorUnionType();
...@@ -191,7 +184,6 @@ fn testErrorUnionType() !void {...@@ -191,7 +184,6 @@ fn testErrorUnionType() !void {
191test "error set type" {184test "error set type" {
192 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;185 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
193 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO186 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
194 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
195 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO187 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
196188
197 try testErrorSetType();189 try testErrorSetType();
...@@ -312,7 +304,6 @@ test "error: Infer error set from literals" {...@@ -312,7 +304,6 @@ test "error: Infer error set from literals" {
312 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;304 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO305 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
314 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO306 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
316 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO307 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
317308
318 _ = nullLiteral("n") catch |err| handleErrors(err);309 _ = nullLiteral("n") catch |err| handleErrors(err);
test/behavior/fn.zig-1
...@@ -216,7 +216,6 @@ fn addPointCoords(pt: Point) i32 {...@@ -216,7 +216,6 @@ fn addPointCoords(pt: Point) i32 {
216}216}
217217
218test "pass by non-copying value through var arg" {218test "pass by non-copying value through var arg" {
219 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;219 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;220 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;...@@ -48,7 +48,6 @@ var global_with_val: anyerror!u32 = 0;
48var global_with_err: anyerror!u32 = error.SomeError;48var global_with_err: anyerror!u32 = error.SomeError;
4949
50test "unwrap mutable global var" {50test "unwrap mutable global var" {
51 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
52 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;51 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
53 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;52 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 {...@@ -20,7 +20,6 @@ fn getErrInt() anyerror!i32 {
20test "ir block deps" {20test "ir block deps" {
21 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;21 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO22 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2423
25 try expect((foo(1) catch unreachable) == 0);24 try expect((foo(1) catch unreachable) == 0);
26 try expect((foo(2) catch unreachable) == 0);25 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;...@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44
5test "namespace depends on compile var" {5test "namespace depends on compile var" {
6 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;6 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
8 if (some_namespace.a_bool) {7 if (some_namespace.a_bool) {
9 try expect(some_namespace.a_bool);8 try expect(some_namespace.a_bool);
10 } else {9 } else {
test/behavior/optional.zig-3
...@@ -28,7 +28,6 @@ pub const EmptyStruct = struct {};...@@ -28,7 +28,6 @@ pub const EmptyStruct = struct {};
28test "optional pointer to size zero struct" {28test "optional pointer to size zero struct" {
29 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;29 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO30 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
31 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
3231
33 var e = EmptyStruct{};32 var e = EmptyStruct{};
34 var o: ?*EmptyStruct = &e;33 var o: ?*EmptyStruct = &e;
...@@ -37,7 +36,6 @@ test "optional pointer to size zero struct" {...@@ -37,7 +36,6 @@ test "optional pointer to size zero struct" {
3736
38test "equality compare optional pointers" {37test "equality compare optional pointers" {
39 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO38 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4139
42 try testNullPtrsEql();40 try testNullPtrsEql();
43 comptime try testNullPtrsEql();41 comptime try testNullPtrsEql();
...@@ -152,7 +150,6 @@ fn test_cmp_optional_non_optional() !void {...@@ -152,7 +150,6 @@ fn test_cmp_optional_non_optional() !void {
152test "unwrap function call with optional pointer return value" {150test "unwrap function call with optional pointer return value" {
153 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;151 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
154 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO152 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
155 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
156153
157 const S = struct {154 const S = struct {
158 fn entry() !void {155 fn entry() !void {
test/behavior/struct.zig-1
...@@ -247,7 +247,6 @@ test "usingnamespace within struct scope" {...@@ -247,7 +247,6 @@ test "usingnamespace within struct scope" {
247247
248test "struct field init with catch" {248test "struct field init with catch" {
249 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;249 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
250 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
251 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;250 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
252251
253 const S = struct {252 const S = struct {
test/behavior/try.zig-1
...@@ -3,7 +3,6 @@ const builtin = @import("builtin");...@@ -3,7 +3,6 @@ const builtin = @import("builtin");
3const expect = std.testing.expect;3const expect = std.testing.expect;
44
5test "try on error union" {5test "try on error union" {
6 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;6 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;7 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98
test/behavior/underscore.zig-1
...@@ -7,7 +7,6 @@ test "ignore lval with underscore" {...@@ -7,7 +7,6 @@ test "ignore lval with underscore" {
7}7}
88
9test "ignore lval with underscore (while loop)" {9test "ignore lval with underscore (while loop)" {
10 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
11 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
12 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;11 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1312
test/behavior/union.zig-7
...@@ -272,7 +272,6 @@ const TheUnion = union(TheTag) {...@@ -272,7 +272,6 @@ const TheUnion = union(TheTag) {
272 C: i32,272 C: i32,
273};273};
274test "cast union to tag type of union" {274test "cast union to tag type of union" {
275 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
277 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;276 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
278277
...@@ -292,7 +291,6 @@ test "union field access gives the enum values" {...@@ -292,7 +291,6 @@ test "union field access gives the enum values" {
292}291}
293292
294test "cast tag type of union to union" {293test "cast tag type of union to union" {
295 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
296 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;294 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
297 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;295 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
298296
...@@ -307,7 +305,6 @@ const Value2 = union(Letter2) {...@@ -307,7 +305,6 @@ const Value2 = union(Letter2) {
307};305};
308306
309test "implicit cast union to its tag type" {307test "implicit cast union to its tag type" {
310 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
311 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;308 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
312 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;309 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313310
...@@ -401,7 +398,6 @@ test "tagged union with no payloads" {...@@ -401,7 +398,6 @@ test "tagged union with no payloads" {
401}398}
402399
403test "union with only 1 field casted to its enum type" {400test "union with only 1 field casted to its enum type" {
404 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
405 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;401 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
406 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;402 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
407403
...@@ -471,7 +467,6 @@ test "initialize global array of union" {...@@ -471,7 +467,6 @@ test "initialize global array of union" {
471}467}
472468
473test "update the tag value for zero-sized unions" {469test "update the tag value for zero-sized unions" {
474 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
475 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;470 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
476 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;471 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...@@ -707,7 +702,6 @@ test "union with only 1 field casted to its enum type which has enum value speci
707}702}
708703
709test "@enumToInt works on unions" {704test "@enumToInt works on unions" {
710 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
711 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO705 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
712 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO706 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
713707
...@@ -841,7 +835,6 @@ test "@unionInit can modify a union type" {...@@ -841,7 +835,6 @@ test "@unionInit can modify a union type" {
841}835}
842836
843test "@unionInit can modify a pointer value" {837test "@unionInit can modify a pointer value" {
844 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
845 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO838 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
846 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO839 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" {...@@ -175,7 +175,6 @@ test "while with optional as condition with else" {
175}175}
176176
177test "while with error union condition" {177test "while with error union condition" {
178 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
179 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;178 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
180 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;179 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
181180
...@@ -248,7 +247,6 @@ fn returnTrue() bool {...@@ -248,7 +247,6 @@ fn returnTrue() bool {
248}247}
249248
250test "return with implicit cast from while loop" {249test "return with implicit cast from while loop" {
251 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
252 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;250 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
253251
254 returnWithImplicitCastFromWhileLoopTest() catch unreachable;252 returnWithImplicitCastFromWhileLoopTest() catch unreachable;
...@@ -260,7 +258,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {...@@ -260,7 +258,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
260}258}
261259
262test "while on error union with else result follow else prong" {260test "while on error union with else result follow else prong" {
263 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
264 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
265 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;262 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" {...@@ -271,7 +268,6 @@ test "while on error union with else result follow else prong" {
271}268}
272269
273test "while on error union with else result follow break prong" {270test "while on error union with else result follow break prong" {
274 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
275 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;271 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
276 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;272 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
277273