authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2023-03-15 13:08:26-04:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2023-03-15 13:08:26-04:00
loga2c6ecd6dc0bdbe2396be9b055852324f16d34c9
tree4931a3dcef12430f8ef7788db233e74559baea46
parent4414f9c46e778a58c6d08df3c6ab604449abf38d
parentd70955b0df92fdd0fdf3680f7f297a4cc676ee5a
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #14918 from jacobly0/x86_64

x86_64: fix various backend crashes

62 files changed, 135 insertions(+), 245 deletions(-)

src/arch/x86_64/CodeGen.zig+134-102
......@@ -184,8 +184,7 @@ const Branch = struct {
184184 _ = options;
185185 comptime assert(unused_format_string.len == 0);
186186 try writer.writeAll("Branch {\n");
187 for (ctx.insts, 0..) |inst, i| {
188 const mcv = ctx.mcvs[i];
187 for (ctx.insts, ctx.mcvs) |inst, mcv| {
189188 try writer.print(" %{d} => {}\n", .{ inst, mcv });
190189 }
191190 try writer.writeAll("}");
......@@ -208,7 +207,7 @@ const Branch = struct {
208207};
209208
210209const StackAllocation = struct {
211 inst: Air.Inst.Index,
210 inst: ?Air.Inst.Index,
212211 /// TODO do we need size? should be determined by inst.ty.abiSize(self.target.*)
213212 size: u32,
214213};
......@@ -1038,9 +1037,9 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
10381037fn processDeath(self: *Self, inst: Air.Inst.Index) void {
10391038 const air_tags = self.air.instructions.items(.tag);
10401039 if (air_tags[inst] == .constant) return; // Constants are immortal.
1041 log.debug("%{d} => {}", .{ inst, MCValue{ .dead = {} } });
1040 const prev_value = self.getResolvedInstValue(inst) orelse return;
1041 log.debug("%{d} => {}", .{ inst, MCValue.dead });
10421042 // When editing this function, note that the logic must synchronize with `reuseOperand`.
1043 const prev_value = self.getResolvedInstValue(inst);
10441043 const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
10451044 branch.inst_table.putAssumeCapacity(inst, .dead);
10461045 switch (prev_value) {
......@@ -1109,7 +1108,7 @@ fn ensureProcessDeathCapacity(self: *Self, additional_count: usize) !void {
11091108 try table.ensureUnusedCapacity(self.gpa, additional_count);
11101109}
11111110
1112fn allocMem(self: *Self, inst: Air.Inst.Index, abi_size: u32, abi_align: u32) !u32 {
1111fn allocMem(self: *Self, inst: ?Air.Inst.Index, abi_size: u32, abi_align: u32) !u32 {
11131112 if (abi_align > self.stack_align)
11141113 self.stack_align = abi_align;
11151114 // TODO find a free slot instead of always appending
......@@ -1142,7 +1141,14 @@ fn allocMemPtr(self: *Self, inst: Air.Inst.Index) !u32 {
11421141}
11431142
11441143fn allocRegOrMem(self: *Self, inst: Air.Inst.Index, reg_ok: bool) !MCValue {
1145 const elem_ty = self.air.typeOfIndex(inst);
1144 return self.allocRegOrMemAdvanced(self.air.typeOfIndex(inst), inst, reg_ok);
1145}
1146
1147fn allocTempRegOrMem(self: *Self, elem_ty: Type, reg_ok: bool) !MCValue {
1148 return self.allocRegOrMemAdvanced(elem_ty, null, reg_ok);
1149}
1150
1151fn allocRegOrMemAdvanced(self: *Self, elem_ty: Type, inst: ?Air.Inst.Index, reg_ok: bool) !MCValue {
11461152 const abi_size = math.cast(u32, elem_ty.abiSize(self.target.*)) orelse {
11471153 const mod = self.bin_file.options.module.?;
11481154 return self.fail("type '{}' too big to fit into stack frame", .{elem_ty.fmt(mod)});
......@@ -1219,7 +1225,7 @@ fn revertState(self: *Self, state: State) void {
12191225pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void {
12201226 const stack_mcv = try self.allocRegOrMem(inst, false);
12211227 log.debug("spilling %{d} to stack mcv {any}", .{ inst, stack_mcv });
1222 const reg_mcv = self.getResolvedInstValue(inst);
1228 const reg_mcv = self.getResolvedInstValue(inst).?;
12231229 switch (reg_mcv) {
12241230 .register => |other| {
12251231 assert(reg.to64() == other.to64());
......@@ -1236,7 +1242,7 @@ pub fn spillInstruction(self: *Self, reg: Register, inst: Air.Inst.Index) !void
12361242
12371243pub fn spillEflagsIfOccupied(self: *Self) !void {
12381244 if (self.eflags_inst) |inst_to_save| {
1239 const mcv = self.getResolvedInstValue(inst_to_save);
1245 const mcv = self.getResolvedInstValue(inst_to_save).?;
12401246 const new_mcv = switch (mcv) {
12411247 .register_overflow => try self.allocRegOrMem(inst_to_save, false),
12421248 .eflags => try self.allocRegOrMem(inst_to_save, true),
......@@ -2861,7 +2867,13 @@ fn store(self: *Self, ptr: MCValue, value: MCValue, ptr_ty: Type, value_ty: Type
28612867 .unreach => unreachable,
28622868 .eflags => unreachable,
28632869 .undef => {
2864 try self.genSetReg(value_ty, reg, value);
2870 switch (abi_size) {
2871 1 => try self.store(ptr, .{ .immediate = 0xaa }, ptr_ty, value_ty),
2872 2 => try self.store(ptr, .{ .immediate = 0xaaaa }, ptr_ty, value_ty),
2873 4 => try self.store(ptr, .{ .immediate = 0xaaaaaaaa }, ptr_ty, value_ty),
2874 8 => try self.store(ptr, .{ .immediate = 0xaaaaaaaaaaaaaaaa }, ptr_ty, value_ty),
2875 else => try self.genInlineMemset(ptr, .{ .immediate = 0xaa }, .{ .immediate = abi_size }, .{}),
2876 }
28652877 },
28662878 .immediate => |imm| {
28672879 switch (abi_size) {
......@@ -3041,6 +3053,9 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
30413053 const mcv = try self.resolveInst(operand);
30423054 const ptr_ty = self.air.typeOf(operand);
30433055 const struct_ty = ptr_ty.childType();
3056 if (struct_ty.zigTypeTag() == .Struct and struct_ty.containerLayout() == .Packed) {
3057 return self.fail("TODO structFieldPtr implement packed structs", .{});
3058 }
30443059 const struct_field_offset = @intCast(u32, struct_ty.structFieldOffset(index, self.target.*));
30453060
30463061 const dst_mcv: MCValue = result: {
......@@ -3104,6 +3119,9 @@ fn airStructFieldVal(self: *Self, inst: Air.Inst.Index) !void {
31043119
31053120 const mcv = try self.resolveInst(operand);
31063121 const struct_ty = self.air.typeOf(operand);
3122 if (struct_ty.zigTypeTag() == .Struct and struct_ty.containerLayout() == .Packed) {
3123 return self.fail("TODO airStructFieldVal implement packed structs", .{});
3124 }
31073125 const struct_field_offset = struct_ty.structFieldOffset(index, self.target.*);
31083126 const struct_field_ty = struct_ty.structFieldType(index);
31093127
......@@ -3625,12 +3643,35 @@ fn genBinOpMir(self: *Self, mir_tag: Mir.Inst.Tag, dst_ty: Type, dst_mcv: MCValu
36253643 ),
36263644 },
36273645 .immediate => |imm| {
3628 // TODO
3629 try self.asmRegisterImmediate(
3630 mir_tag,
3631 registerAlias(dst_reg, abi_size),
3632 Immediate.u(@intCast(u32, imm)),
3633 );
3646 switch (abi_size) {
3647 0 => unreachable,
3648 1...4 => {
3649 try self.asmRegisterImmediate(
3650 mir_tag,
3651 registerAlias(dst_reg, abi_size),
3652 Immediate.u(@intCast(u32, imm)),
3653 );
3654 },
3655 5...8 => {
3656 if (math.cast(i32, @bitCast(i64, imm))) |small| {
3657 try self.asmRegisterImmediate(
3658 mir_tag,
3659 registerAlias(dst_reg, abi_size),
3660 Immediate.s(small),
3661 );
3662 } else {
3663 const tmp_reg = try self.register_manager.allocReg(null, gp);
3664 const tmp_alias = registerAlias(tmp_reg, abi_size);
3665 try self.asmRegisterImmediate(.mov, tmp_alias, Immediate.u(imm));
3666 try self.asmRegisterRegister(
3667 mir_tag,
3668 registerAlias(dst_reg, abi_size),
3669 tmp_alias,
3670 );
3671 }
3672 },
3673 else => return self.fail("TODO getBinOpMir implement large immediate ABI", .{}),
3674 }
36343675 },
36353676 .memory,
36363677 .linker_load,
......@@ -3969,10 +4010,10 @@ fn airCall(self: *Self, inst: Air.Inst.Index, modifier: std.builtin.CallModifier
39694010 };
39704011 defer if (ret_reg_lock) |lock| self.register_manager.unlockReg(lock);
39714012
3972 for (args, 0..) |arg, arg_i| {
3973 const mc_arg = info.args[arg_i];
4013 for (args, info.args) |arg, info_arg| {
4014 const mc_arg = info_arg;
39744015 const arg_ty = self.air.typeOf(arg);
3975 const arg_mcv = try self.resolveInst(args[arg_i]);
4016 const arg_mcv = try self.resolveInst(arg);
39764017 // Here we do not use setRegOrMem even though the logic is similar, because
39774018 // the function call will move the stack pointer, so the offsets are different.
39784019 switch (mc_arg) {
......@@ -4410,16 +4451,16 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
44104451 // Capture the state of register and stack allocation state so that we can revert to it.
44114452 const saved_state = try self.captureState();
44124453
4413 try self.branch_stack.append(.{});
4414 errdefer {
4415 _ = self.branch_stack.pop();
4416 }
4454 {
4455 try self.branch_stack.append(.{});
4456 errdefer _ = self.branch_stack.pop();
44174457
4418 try self.ensureProcessDeathCapacity(liveness_condbr.then_deaths.len);
4419 for (liveness_condbr.then_deaths) |operand| {
4420 self.processDeath(operand);
4458 try self.ensureProcessDeathCapacity(liveness_condbr.then_deaths.len);
4459 for (liveness_condbr.then_deaths) |operand| {
4460 self.processDeath(operand);
4461 }
4462 try self.genBody(then_body);
44214463 }
4422 try self.genBody(then_body);
44234464
44244465 // Revert to the previous register and stack allocation state.
44254466
......@@ -4430,16 +4471,16 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
44304471
44314472 try self.performReloc(reloc);
44324473
4433 try self.branch_stack.append(.{});
4434 errdefer {
4435 _ = self.branch_stack.pop();
4436 }
4474 {
4475 try self.branch_stack.append(.{});
4476 errdefer _ = self.branch_stack.pop();
44374477
4438 try self.ensureProcessDeathCapacity(liveness_condbr.else_deaths.len);
4439 for (liveness_condbr.else_deaths) |operand| {
4440 self.processDeath(operand);
4478 try self.ensureProcessDeathCapacity(liveness_condbr.else_deaths.len);
4479 for (liveness_condbr.else_deaths) |operand| {
4480 self.processDeath(operand);
4481 }
4482 try self.genBody(else_body);
44414483 }
4442 try self.genBody(else_body);
44434484
44444485 var else_branch = self.branch_stack.pop();
44454486 defer else_branch.deinit(self.gpa);
......@@ -4565,18 +4606,16 @@ fn airIsNullPtr(self: *Self, inst: Air.Inst.Index) !void {
45654606 };
45664607 defer if (operand_ptr_lock) |lock| self.register_manager.unlockReg(lock);
45674608
4568 const operand: MCValue = blk: {
4569 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
4570 // The MCValue that holds the pointer can be re-used as the value.
4571 break :blk operand_ptr;
4572 } else {
4573 break :blk try self.allocRegOrMem(inst, true);
4574 }
4575 };
45764609 const ptr_ty = self.air.typeOf(un_op);
4610 const elem_ty = ptr_ty.childType();
4611 const operand = if (elem_ty.isPtrLikeOptional() and self.reuseOperand(inst, un_op, 0, operand_ptr))
4612 // The MCValue that holds the pointer can be re-used as the value.
4613 operand_ptr
4614 else
4615 try self.allocTempRegOrMem(elem_ty, true);
45774616 try self.load(operand, operand_ptr, ptr_ty);
45784617
4579 const result = try self.isNull(inst, ptr_ty.elemType(), operand);
4618 const result = try self.isNull(inst, elem_ty, operand);
45804619
45814620 return self.finishAir(inst, result, .{ un_op, .none, .none });
45824621}
......@@ -4605,15 +4644,13 @@ fn airIsNonNullPtr(self: *Self, inst: Air.Inst.Index) !void {
46054644 };
46064645 defer if (operand_ptr_lock) |lock| self.register_manager.unlockReg(lock);
46074646
4608 const operand: MCValue = blk: {
4609 if (self.reuseOperand(inst, un_op, 0, operand_ptr)) {
4610 // The MCValue that holds the pointer can be re-used as the value.
4611 break :blk operand_ptr;
4612 } else {
4613 break :blk try self.allocRegOrMem(inst, true);
4614 }
4615 };
46164647 const ptr_ty = self.air.typeOf(un_op);
4648 const elem_ty = ptr_ty.childType();
4649 const operand = if (elem_ty.isPtrLikeOptional() and self.reuseOperand(inst, un_op, 0, operand_ptr))
4650 // The MCValue that holds the pointer can be re-used as the value.
4651 operand_ptr
4652 else
4653 try self.allocTempRegOrMem(elem_ty, true);
46174654 try self.load(operand, operand_ptr, ptr_ty);
46184655
46194656 const result = try self.isNonNull(inst, ptr_ty.elemType(), operand);
......@@ -4721,7 +4758,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
47214758 // break instruction will choose a MCValue for the block result and overwrite
47224759 // this field. Following break instructions will use that MCValue to put their
47234760 // block results.
4724 .mcv = MCValue{ .none = {} },
4761 .mcv = .none,
47254762 });
47264763 defer self.blocks.getPtr(inst).?.relocs.deinit(self.gpa);
47274764
......@@ -4842,25 +4879,25 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
48424879 var relocs = try self.gpa.alloc(u32, items.len);
48434880 defer self.gpa.free(relocs);
48444881
4845 for (items, 0..) |item, item_i| {
4882 for (items, relocs) |item, *reloc| {
48464883 const item_mcv = try self.resolveInst(item);
4847 relocs[item_i] = try self.genCondSwitchMir(condition_ty, condition, item_mcv);
4884 reloc.* = try self.genCondSwitchMir(condition_ty, condition, item_mcv);
48484885 }
48494886
48504887 // Capture the state of register and stack allocation state so that we can revert to it.
48514888 const saved_state = try self.captureState();
48524889
4853 try self.branch_stack.append(.{});
4854 errdefer {
4855 _ = self.branch_stack.pop();
4856 }
4890 {
4891 try self.branch_stack.append(.{});
4892 errdefer _ = self.branch_stack.pop();
48574893
4858 try self.ensureProcessDeathCapacity(liveness.deaths[case_i].len);
4859 for (liveness.deaths[case_i]) |operand| {
4860 self.processDeath(operand);
4861 }
4894 try self.ensureProcessDeathCapacity(liveness.deaths[case_i].len);
4895 for (liveness.deaths[case_i]) |operand| {
4896 self.processDeath(operand);
4897 }
48624898
4863 try self.genBody(case_body);
4899 try self.genBody(case_body);
4900 }
48644901
48654902 branch_stack.appendAssumeCapacity(self.branch_stack.pop());
48664903
......@@ -4878,18 +4915,18 @@ fn airSwitch(self: *Self, inst: Air.Inst.Index) !void {
48784915 // Capture the state of register and stack allocation state so that we can revert to it.
48794916 const saved_state = try self.captureState();
48804917
4881 try self.branch_stack.append(.{});
4882 errdefer {
4883 _ = self.branch_stack.pop();
4884 }
4918 {
4919 try self.branch_stack.append(.{});
4920 errdefer _ = self.branch_stack.pop();
48854921
4886 const else_deaths = liveness.deaths.len - 1;
4887 try self.ensureProcessDeathCapacity(liveness.deaths[else_deaths].len);
4888 for (liveness.deaths[else_deaths]) |operand| {
4889 self.processDeath(operand);
4890 }
4922 const else_deaths = liveness.deaths.len - 1;
4923 try self.ensureProcessDeathCapacity(liveness.deaths[else_deaths].len);
4924 for (liveness.deaths[else_deaths]) |operand| {
4925 self.processDeath(operand);
4926 }
48914927
4892 try self.genBody(else_body);
4928 try self.genBody(else_body);
4929 }
48934930
48944931 branch_stack.appendAssumeCapacity(self.branch_stack.pop());
48954932
......@@ -4926,11 +4963,7 @@ fn canonicaliseBranches(self: *Self, parent_branch: *Branch, canon_branch: *Bran
49264963 try parent_branch.inst_table.ensureUnusedCapacity(self.gpa, target_branch.inst_table.count());
49274964
49284965 const target_slice = target_branch.inst_table.entries.slice();
4929 const target_keys = target_slice.items(.key);
4930 const target_values = target_slice.items(.value);
4931
4932 for (target_keys, 0..) |target_key, target_idx| {
4933 const target_value = target_values[target_idx];
4966 for (target_slice.items(.key), target_slice.items(.value)) |target_key, target_value| {
49344967 const canon_mcv = if (canon_branch.inst_table.fetchSwapRemove(target_key)) |canon_entry| blk: {
49354968 // The instruction's MCValue is overridden in both branches.
49364969 parent_branch.inst_table.putAssumeCapacity(target_key, canon_entry.value);
......@@ -4960,10 +4993,7 @@ fn canonicaliseBranches(self: *Self, parent_branch: *Branch, canon_branch: *Bran
49604993 }
49614994 try parent_branch.inst_table.ensureUnusedCapacity(self.gpa, canon_branch.inst_table.count());
49624995 const canon_slice = canon_branch.inst_table.entries.slice();
4963 const canon_keys = canon_slice.items(.key);
4964 const canon_values = canon_slice.items(.value);
4965 for (canon_keys, 0..) |canon_key, canon_idx| {
4966 const canon_value = canon_values[canon_idx];
4996 for (canon_slice.items(.key), canon_slice.items(.value)) |canon_key, canon_value| {
49674997 // We already deleted the items from this table that matched the target_branch.
49684998 // So these are all instructions that are only overridden in the canon branch.
49694999 parent_branch.inst_table.putAssumeCapacity(canon_key, canon_value);
......@@ -5144,9 +5174,9 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
51445174 const reg_name = output[2 .. output.len - 1];
51455175 const reg = parseRegName(reg_name) orelse
51465176 return self.fail("unrecognized register: '{s}'", .{reg_name});
5147 break :result MCValue{ .register = reg };
5177 break :result .{ .register = reg };
51485178 } else {
5149 break :result MCValue{ .none = {} };
5179 break :result .none;
51505180 }
51515181 };
51525182
......@@ -6218,6 +6248,9 @@ fn airAggregateInit(self: *Self, inst: Air.Inst.Index) !void {
62186248 if (self.liveness.isUnused(inst)) break :res MCValue.dead;
62196249 switch (result_ty.zigTypeTag()) {
62206250 .Struct => {
6251 if (result_ty.containerLayout() == .Packed) {
6252 return self.fail("TODO airAggregateInit implement packed structs", .{});
6253 }
62216254 const stack_offset = @intCast(i32, try self.allocMem(inst, abi_size, abi_align));
62226255 for (elements, 0..) |elem, elem_i| {
62236256 if (result_ty.structFieldValueComptime(elem_i) != null) continue; // comptime elem
......@@ -6288,7 +6321,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
62886321 if (ref_int < Air.Inst.Ref.typed_value_map.len) {
62896322 const tv = Air.Inst.Ref.typed_value_map[ref_int];
62906323 if (!tv.ty.hasRuntimeBitsIgnoreComptime() and !tv.ty.isError()) {
6291 return MCValue{ .none = {} };
6324 return .none;
62926325 }
62936326 return self.genTypedValue(tv);
62946327 }
......@@ -6296,7 +6329,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
62966329 // If the type has no codegen bits, no need to store it.
62976330 const inst_ty = self.air.typeOf(inst);
62986331 if (!inst_ty.hasRuntimeBitsIgnoreComptime() and !inst_ty.isError())
6299 return MCValue{ .none = {} };
6332 return .none;
63006333
63016334 const inst_index = @intCast(Air.Inst.Index, ref_int - Air.Inst.Ref.typed_value_map.len);
63026335 switch (self.air.instructions.items(.tag)[inst_index]) {
......@@ -6314,18 +6347,17 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
63146347 return gop.value_ptr.*;
63156348 },
63166349 .const_ty => unreachable,
6317 else => return self.getResolvedInstValue(inst_index),
6350 else => return self.getResolvedInstValue(inst_index).?,
63186351 }
63196352}
63206353
6321fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) MCValue {
6354fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) ?MCValue {
63226355 // Treat each stack item as a "layer" on top of the previous one.
63236356 var i: usize = self.branch_stack.items.len;
63246357 while (true) {
63256358 i -= 1;
63266359 if (self.branch_stack.items[i].inst_table.get(inst)) |mcv| {
6327 assert(mcv != .dead);
6328 return mcv;
6360 return if (mcv != .dead) mcv else null;
63296361 }
63306362 }
63316363}
......@@ -6405,7 +6437,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64056437 switch (cc) {
64066438 .Naked => {
64076439 assert(result.args.len == 0);
6408 result.return_value = .{ .unreach = {} };
6440 result.return_value = .unreach;
64096441 result.stack_byte_count = 0;
64106442 result.stack_align = 1;
64116443 return result;
......@@ -6413,10 +6445,10 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64136445 .C => {
64146446 // Return values
64156447 if (ret_ty.zigTypeTag() == .NoReturn) {
6416 result.return_value = .{ .unreach = {} };
6448 result.return_value = .unreach;
64176449 } else if (!ret_ty.hasRuntimeBitsIgnoreComptime() and !ret_ty.isError()) {
64186450 // TODO: is this even possible for C calling convention?
6419 result.return_value = .{ .none = {} };
6451 result.return_value = .none;
64206452 } else {
64216453 const ret_ty_size = @intCast(u32, ret_ty.abiSize(self.target.*));
64226454 if (ret_ty_size == 0) {
......@@ -6437,7 +6469,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64376469 else => 0,
64386470 };
64396471
6440 for (param_types, 0..) |ty, i| {
6472 for (param_types, result.args, 0..) |ty, *arg, i| {
64416473 assert(ty.hasRuntimeBits());
64426474
64436475 const classes: []const abi.Class = switch (self.target.os.tag) {
......@@ -6450,7 +6482,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64506482 switch (classes[0]) {
64516483 .integer => blk: {
64526484 if (i >= abi.getCAbiIntParamRegs(self.target.*).len) break :blk; // fallthrough
6453 result.args[i] = .{ .register = abi.getCAbiIntParamRegs(self.target.*)[i] };
6485 arg.* = .{ .register = abi.getCAbiIntParamRegs(self.target.*)[i] };
64546486 continue;
64556487 },
64566488 .memory => {}, // fallthrough
......@@ -6462,7 +6494,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64626494 const param_size = @intCast(u32, ty.abiSize(self.target.*));
64636495 const param_align = @intCast(u32, ty.abiAlignment(self.target.*));
64646496 const offset = mem.alignForwardGeneric(u32, next_stack_offset + param_size, param_align);
6465 result.args[i] = .{ .stack_offset = @intCast(i32, offset) };
6497 arg.* = .{ .stack_offset = @intCast(i32, offset) };
64666498 next_stack_offset = offset;
64676499 }
64686500
......@@ -6488,9 +6520,9 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
64886520 .Unspecified => {
64896521 // Return values
64906522 if (ret_ty.zigTypeTag() == .NoReturn) {
6491 result.return_value = .{ .unreach = {} };
6523 result.return_value = .unreach;
64926524 } else if (!ret_ty.hasRuntimeBitsIgnoreComptime() and !ret_ty.isError()) {
6493 result.return_value = .{ .none = {} };
6525 result.return_value = .none;
64946526 } else {
64956527 const ret_ty_size = @intCast(u32, ret_ty.abiSize(self.target.*));
64966528 if (ret_ty_size == 0) {
......@@ -6513,15 +6545,15 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
65136545 else => 0,
65146546 };
65156547
6516 for (param_types, 0..) |ty, i| {
6548 for (param_types, result.args) |ty, *arg| {
65176549 if (!ty.hasRuntimeBits()) {
6518 result.args[i] = .{ .none = {} };
6550 arg.* = .none;
65196551 continue;
65206552 }
65216553 const param_size = @intCast(u32, ty.abiSize(self.target.*));
65226554 const param_align = @intCast(u32, ty.abiAlignment(self.target.*));
65236555 const offset = mem.alignForwardGeneric(u32, next_stack_offset + param_size, param_align);
6524 result.args[i] = .{ .stack_offset = @intCast(i32, offset) };
6556 arg.* = .{ .stack_offset = @intCast(i32, offset) };
65256557 next_stack_offset = offset;
65266558 }
65276559
test/behavior/align.zig-1
......@@ -568,7 +568,6 @@ fn overaligned_fn() align(0x1000) i32 {
568568}
569569
570570test "comptime alloc alignment" {
571 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
572571 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
573572 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
574573 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
test/behavior/array.zig-1
......@@ -591,7 +591,6 @@ test "type coercion of anon struct literal to array" {
591591test "type coercion of pointer to anon struct literal to pointer to array" {
592592 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
593593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
594 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
595594 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
596595
597596 const S = struct {
test/behavior/bit_shifting.zig-1
......@@ -63,7 +63,6 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt
6363test "sharded table" {
6464 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6565 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
6766 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6867
6968 // realistic 16-way sharding
test/behavior/bitreverse.zig-1
......@@ -150,7 +150,6 @@ fn vector0() !void {
150150
151151test "bitReverse vectors u0" {
152152 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
153 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
154153
155154 comptime try vector0();
156155 try vector0();
test/behavior/bugs/1076.zig-1
......@@ -4,7 +4,6 @@ const mem = std.mem;
44const expect = std.testing.expect;
55
66test "comptime code should not modify constant data" {
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
109
test/behavior/bugs/11046.zig-1
......@@ -10,7 +10,6 @@ fn bar() !void {
1010}
1111
1212test "fixed" {
13 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1413 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1514 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1615 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/bugs/11787.zig-1
......@@ -4,7 +4,6 @@ const testing = std.testing;
44
55test "slicing zero length array field of struct" {
66 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/12000.zig-1
......@@ -7,7 +7,6 @@ const T = struct {
77
88test {
99 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
10 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1312 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/12119.zig-1
......@@ -6,7 +6,6 @@ const u32x8 = @Vector(8, u32);
66
77test {
88 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/12169.zig-1
......@@ -3,7 +3,6 @@ const builtin = @import("builtin");
33
44test {
55 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
6 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
76 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/12890.zig-1
......@@ -10,7 +10,6 @@ fn a(b: []u3, c: u3) void {
1010}
1111test {
1212 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1413 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1514
1615 var arr: [8]u3 = undefined;
test/behavior/bugs/13113.zig-1
......@@ -8,7 +8,6 @@ const Foo = extern struct {
88
99test {
1010 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1312 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1413 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/1421.zig-1
......@@ -9,7 +9,6 @@ const S = struct {
99};
1010
1111test "functions with return type required to be comptime are generic" {
12 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1312 const ti = S.method();
1413 try expect(@as(std.builtin.TypeId, ti) == std.builtin.TypeId.Struct);
1514}
test/behavior/bugs/1607.zig-1
......@@ -13,7 +13,6 @@ fn checkAddress(s: []const u8) !void {
1313test "slices pointing at the same address as global array." {
1414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1716 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1817 try checkAddress(&a);
1918 comptime try checkAddress(&a);
test/behavior/bugs/2622.zig-1
......@@ -4,7 +4,6 @@ var buf: []u8 = undefined;
44
55test "reslice of undefined global var slice" {
66 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/2727.zig-1
......@@ -6,7 +6,6 @@ fn t() bool {
66
77test {
88 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/bugs/3742.zig-1
......@@ -37,7 +37,6 @@ pub const ArgSerializer = struct {
3737test "fixed" {
3838 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3939 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
40 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
4140 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
4241 if (builtin.zig_backend == .stage2_llvm and
4342 builtin.cpu.arch == .aarch64 and builtin.os.tag == .windows) return error.SkipZigTest;
test/behavior/bugs/394.zig-1
......@@ -11,7 +11,6 @@ const expect = @import("std").testing.expect;
1111const builtin = @import("builtin");
1212
1313test "fixed" {
14 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1514 const x = S{
1615 .x = 3,
1716 .y = E{ .B = 1 },
test/behavior/bugs/421.zig-1
......@@ -2,7 +2,6 @@ const builtin = @import("builtin");
22const expect = @import("std").testing.expect;
33
44test "bitCast to array" {
5 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
65 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
76 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/bugs/5398.zig-1
......@@ -21,7 +21,6 @@ var renderable: Renderable = undefined;
2121test "assignment of field with padding" {
2222 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2323 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
24 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2524 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2625
2726 renderable = Renderable{
test/behavior/bugs/5487.zig-1
......@@ -12,7 +12,6 @@ pub fn writer() io.Writer(void, @typeInfo(@typeInfo(@TypeOf(write)).Fn.return_ty
1212test "crash" {
1313 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1414 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1615 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1716 _ = io.multiWriter(.{writer()});
1817}
test/behavior/bugs/656.zig-1
......@@ -13,7 +13,6 @@ const Value = struct {
1313test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
1414 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1515 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1716 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1817 try foo(false, true);
1918}
test/behavior/bugs/6947.zig-1
......@@ -6,7 +6,6 @@ fn destroy(ptr: *void) void {
66
77test {
88 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
9 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_x86) return error.SkipZigTest; // TODO
1110 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1211 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
test/behavior/byteswap.zig-1
......@@ -116,7 +116,6 @@ fn vector0() !void {
116116
117117test "@byteSwap vectors u0" {
118118 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
119 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
120119
121120 comptime try vector0();
122121 try vector0();
test/behavior/byval_arg_var.zig-1
......@@ -4,7 +4,6 @@ const builtin = @import("builtin");
44var result: []const u8 = "wrong";
55
66test "pass string literal byvalue to a generic var param" {
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98
109 start();
test/behavior/call.zig-2
......@@ -21,7 +21,6 @@ test "super basic invocations" {
2121test "basic invocations" {
2222 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
2323 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2524 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2625 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2726 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -56,7 +55,6 @@ test "basic invocations" {
5655test "tuple parameters" {
5756 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5857 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
59 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
6058 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6159
6260 const add = struct {
test/behavior/cast.zig-9
......@@ -176,7 +176,6 @@ fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void {
176176
177177test "implicitly cast indirect pointer to maybe-indirect pointer" {
178178 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
179 if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
180179 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
181180
182181 const S = struct {
......@@ -318,7 +317,6 @@ test "peer result null and comptime_int" {
318317
319318test "*const ?[*]const T to [*c]const [*c]const T" {
320319 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
321 if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
322320 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
323321
324322 var array = [_]u8{ 'o', 'k' };
......@@ -588,7 +586,6 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
588586
589587test "cast *[1][*]const u8 to [*]const ?[*]const u8" {
590588 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
591 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
592589 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
593590
594591 const window_name = [1][*]const u8{"window name"};
......@@ -927,7 +924,6 @@ test "peer cast *[N:x]T to *[N]T" {
927924
928925test "peer cast [*:x]T to [*]T" {
929926 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
930 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
931927 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
932928
933929 const S = struct {
......@@ -948,7 +944,6 @@ test "peer cast [*:x]T to [*]T" {
948944test "peer cast [:x]T to [*:x]T" {
949945 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
950946 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
951 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
952947 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
953948
954949 const S = struct {
......@@ -989,7 +984,6 @@ test "peer type resolution implicit cast to return type" {
989984
990985test "peer type resolution implicit cast to variable type" {
991986 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
992 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
993987 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
994988
995989 const S = struct {
......@@ -1112,8 +1106,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
11121106}
11131107
11141108test "compile time int to ptr of function" {
1115 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1116
11171109 try foobar(FUNCTION_CONSTANT);
11181110}
11191111
......@@ -1505,7 +1497,6 @@ test "implicit cast from [:0]T to [*c]T" {
15051497test "bitcast packed struct with u0" {
15061498 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15071499 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1508 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
15091500
15101501 const S = packed struct(u2) { a: u0, b: u2 };
15111502 const s = @bitCast(S, @as(u2, 2));
test/behavior/defer.zig-1
......@@ -50,7 +50,6 @@ fn testNestedFnErrDefer() anyerror!void {
5050}
5151
5252test "return variable while defer expression in scope to modify it" {
53 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
5453 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5554 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5655 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/enum.zig-2
......@@ -937,7 +937,6 @@ test "enum literal casting to error union with payload enum" {
937937}
938938
939939test "constant enum initialization with differing sizes" {
940 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
941940 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
942941 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
943942 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1137,7 +1136,6 @@ test "tag name functions are unique" {
11371136}
11381137
11391138test "size of enum with only one tag which has explicit integer tag type" {
1140 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
11411139 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11421140 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11431141
test/behavior/error.zig-10
......@@ -144,15 +144,11 @@ test "implicit cast to optional to error union to return result loc" {
144144}
145145
146146test "fn returning empty error set can be passed as fn returning any error" {
147 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
148
149147 entry();
150148 comptime entry();
151149}
152150
153151test "fn returning empty error set can be passed as fn returning any error - pointer" {
154 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
155
156152 entryPtr();
157153 comptime entryPtr();
158154}
......@@ -219,7 +215,6 @@ fn testErrorSetType() !void {
219215}
220216
221217test "explicit error set cast" {
222 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
223218 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224219
225220 try testExplicitErrorSetCast(Set1.A);
......@@ -238,7 +233,6 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
238233}
239234
240235test "comptime test error for empty error set" {
241 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
242236 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243237
244238 try testComptimeTestErrorEmptySet(1234);
......@@ -255,8 +249,6 @@ fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void {
255249}
256250
257251test "comptime err to int of error set with only 1 possible value" {
258 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
259
260252 testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
261253 comptime testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
262254}
......@@ -426,7 +418,6 @@ test "nested error union function call in optional unwrap" {
426418}
427419
428420test "return function call to error set from error union function" {
429 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
430421 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
431422 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
432423
......@@ -486,7 +477,6 @@ test "nested catch" {
486477}
487478
488479test "function pointer with return type that is error union with payload which is pointer of parent struct" {
489 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
490480 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
491481
492482 const S = struct {
test/behavior/eval.zig-2
......@@ -138,7 +138,6 @@ test "pointer to type" {
138138}
139139
140140test "a type constructed in a global expression" {
141 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
142141 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
143142 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
144143
......@@ -1515,7 +1514,6 @@ test "x or true is comptime-known true" {
15151514}
15161515
15171516test "non-optional and optional array elements concatenated" {
1518 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
15191517 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15201518 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15211519 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
test/behavior/floatop.zig-7
......@@ -21,7 +21,6 @@ fn epsForType(comptime T: type) T {
2121
2222test "floating point comparisons" {
2323 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
24 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2524 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
2625
2726 try testFloatComparisons();
......@@ -91,7 +90,6 @@ fn testDifferentSizedFloatComparisons() !void {
9190
9291test "negative f128 floatToInt at compile-time" {
9392 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
94 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9694 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9795
......@@ -331,7 +329,6 @@ fn testExpWithVectors() !void {
331329
332330test "@exp2" {
333331 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
334 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
335332 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
336333 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
337334 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -500,7 +497,6 @@ fn testLog10WithVectors() !void {
500497
501498test "@fabs" {
502499 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
503 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
504500 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
505501 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
506502 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -627,7 +623,6 @@ test "a third @fabs test, surely there should not be three fabs tests" {
627623
628624test "@floor" {
629625 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
630 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
631626 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
632627 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
633628 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -720,7 +715,6 @@ fn testFloorLegacy(comptime T: type, x: T) !void {
720715
721716test "@ceil" {
722717 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
723 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
724718 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
725719 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
726720 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -813,7 +807,6 @@ fn testCeilLegacy(comptime T: type, x: T) !void {
813807
814808test "@trunc" {
815809 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
816 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
817810 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
818811 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
819812 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/fn.zig-2
......@@ -275,7 +275,6 @@ test "implicit cast fn call result to optional in field result" {
275275}
276276
277277test "void parameters" {
278 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
279278 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
280279 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
281280
......@@ -300,7 +299,6 @@ fn acceptsString(foo: []u8) void {
300299}
301300
302301test "function pointers" {
303 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
304302 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
305303 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
306304 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/for.zig-8
......@@ -110,7 +110,6 @@ test "basic for loop" {
110110}
111111
112112test "for with null and T peer types and inferred result location type" {
113 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
114113 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
115114 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
116115 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -152,7 +151,6 @@ test "2 break statements and an else" {
152151}
153152
154153test "for loop with pointer elem var" {
155 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
156154 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
157155 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
158156 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -198,7 +196,6 @@ test "for copies its payload" {
198196}
199197
200198test "for on slice with allowzero ptr" {
201 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
202199 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
203200 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
204201 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -253,7 +250,6 @@ test "for loop with else branch" {
253250test "count over fixed range" {
254251 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
255252 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
256 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
257253
258254 var sum: usize = 0;
259255 for (0..6) |i| {
......@@ -266,7 +262,6 @@ test "count over fixed range" {
266262test "two counters" {
267263 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
268264 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
269 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
270265
271266 var sum: usize = 0;
272267 for (0..10, 10..20) |i, j| {
......@@ -280,7 +275,6 @@ test "two counters" {
280275test "1-based counter and ptr to array" {
281276 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
282277 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
283 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
284278
285279 var ok: usize = 0;
286280
......@@ -401,7 +395,6 @@ test "raw pointer and counter" {
401395test "inline for with slice as the comptime-known" {
402396 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
403397 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
404 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
405398 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
406399
407400 const comptime_slice = "hello";
......@@ -432,7 +425,6 @@ test "inline for with slice as the comptime-known" {
432425test "inline for with counter as the comptime-known" {
433426 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
434427 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
435 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
436428 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
437429
438430 var runtime_slice = "hello";
test/behavior/generics.zig-3
......@@ -56,7 +56,6 @@ fn sameButWithFloats(a: f64, b: f64) f64 {
5656}
5757
5858test "fn with comptime args" {
59 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
6059 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6160 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6261 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -67,7 +66,6 @@ test "fn with comptime args" {
6766}
6867
6968test "anytype params" {
70 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
7169 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7270 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7371 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -93,7 +91,6 @@ fn max_f64(a: f64, b: f64) f64 {
9391}
9492
9593test "type constructed by comptime function call" {
96 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
9794 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9895 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9996
test/behavior/if.zig-1
......@@ -78,7 +78,6 @@ test "const result loc, runtime if cond, else unreachable" {
7878}
7979
8080test "if copies its payload" {
81 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
8281 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8382 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8483
test/behavior/inline_switch.zig-1
......@@ -46,7 +46,6 @@ const U = union(E) { a: void, b: u2, c: u3, d: u4 };
4646test "inline switch unions" {
4747 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
4848 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
5049 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5150
5251 var x: U = .a;
test/behavior/member_func.zig-2
......@@ -27,7 +27,6 @@ const HasFuncs = struct {
2727};
2828
2929test "standard field calls" {
30 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
3130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3231 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -71,7 +70,6 @@ test "standard field calls" {
7170}
7271
7372test "@field field calls" {
74 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
7573 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7674 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7775 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/null.zig-3
......@@ -50,7 +50,6 @@ test "rhs maybe unwrap return" {
5050}
5151
5252test "maybe return" {
53 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
5453 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5554 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5655 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -71,7 +70,6 @@ fn foo(x: ?i32) ?bool {
7170}
7271
7372test "test null runtime" {
74 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
7573 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7674 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7775
......@@ -184,7 +182,6 @@ const SillyStruct = struct {
184182const here_is_a_null_literal = SillyStruct{ .context = null };
185183
186184test "unwrap optional which is field of global var" {
187 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
188185 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
189186 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
190187 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/optional.zig-1
......@@ -274,7 +274,6 @@ test "0-bit child type coerced to optional return ptr result location" {
274274}
275275
276276test "0-bit child type coerced to optional" {
277 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
278277 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
279278
280279 const S = struct {
test/behavior/pointers.zig-2
......@@ -190,7 +190,6 @@ test "compare equality of optional and non-optional pointer" {
190190test "allowzero pointer and slice" {
191191 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
192192 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
193 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
194193 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
195194 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196195
......@@ -510,7 +509,6 @@ test "ptrToInt on a generic function" {
510509 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
511510 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
512511 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
513 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
514512
515513 const S = struct {
516514 fn generic(i: anytype) @TypeOf(i) {
test/behavior/ptrcast.zig-1
......@@ -53,7 +53,6 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
5353}
5454
5555test "reinterpret bytes of an array into an extern struct" {
56 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
5756 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
5857 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
5958
test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig-1
......@@ -5,7 +5,6 @@ const mem = std.mem;
55
66var ok: bool = false;
77test "reference a variable in an if after an if in the 2nd switch prong" {
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 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/reflection.zig-1
......@@ -27,7 +27,6 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
2727
2828test "reflection: @field" {
2929 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
3130 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3231
3332 var f = Foo{
test/behavior/sizeof_and_typeof.zig-3
......@@ -18,7 +18,6 @@ test "@sizeOf on compile-time types" {
1818}
1919
2020test "@TypeOf() with multiple arguments" {
21 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
2221 {
2322 var var_1: u32 = undefined;
2423 var var_2: u8 = undefined;
......@@ -138,7 +137,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
138137}
139138
140139test "@TypeOf() has no runtime side effects" {
141 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
142140 const S = struct {
143141 fn foo(comptime T: type, ptr: *T) T {
144142 ptr.* += 1;
......@@ -153,7 +151,6 @@ test "@TypeOf() has no runtime side effects" {
153151
154152test "branching logic inside @TypeOf" {
155153 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
156 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
157154 const S = struct {
158155 var data: i32 = 0;
159156 fn foo() anyerror!i32 {
test/behavior/slice.zig-9
......@@ -119,7 +119,6 @@ test "slice of type" {
119119}
120120
121121test "generic malloc free" {
122 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
123122 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
124123
125124 const a = memAlloc(u8, 10) catch unreachable;
......@@ -171,7 +170,6 @@ test "comptime pointer cast array and then slice" {
171170
172171test "slicing zero length array" {
173172 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
174 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
175173 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
176174
177175 const s1 = ""[0..];
......@@ -185,8 +183,6 @@ test "slicing zero length array" {
185183const x = @intToPtr([*]i32, 0x1000)[0..0x500];
186184const y = x[0x100..];
187185test "compile time slice of pointer to hard coded address" {
188 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
189
190186 try expect(@ptrToInt(x) == 0x1000);
191187 try expect(x.len == 0x500);
192188
......@@ -342,7 +338,6 @@ test "@ptrCast slice to pointer" {
342338}
343339
344340test "slice syntax resulting in pointer-to-array" {
345 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
346341 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
347342 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
348343 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -477,7 +472,6 @@ test "slice syntax resulting in pointer-to-array" {
477472}
478473
479474test "slice pointer-to-array null terminated" {
480 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
481475 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
482476 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
483477
......@@ -497,7 +491,6 @@ test "slice pointer-to-array null terminated" {
497491}
498492
499493test "slice pointer-to-array zero length" {
500 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
501494 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
502495
503496 comptime {
......@@ -530,7 +523,6 @@ test "slice pointer-to-array zero length" {
530523}
531524
532525test "type coercion of pointer to anon struct literal to pointer to slice" {
533 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
534526 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
535527 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
536528 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -730,7 +722,6 @@ test "slice with dereferenced value" {
730722
731723test "empty slice ptr is non null" {
732724 if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest; // TODO
733 if (builtin.zig_backend == .stage2_x86_64 and (builtin.os.tag == .macos or builtin.os.tag == .windows)) return error.SkipZigTest; // TODO
734725
735726 const empty_slice: []u8 = &[_]u8{};
736727 const p: [*]u8 = empty_slice.ptr + 0;
test/behavior/struct.zig-5
......@@ -342,7 +342,6 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {
342342test "self-referencing struct via array member" {
343343 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
344344 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
345 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
346345 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
347346
348347 const T = struct {
......@@ -536,7 +535,6 @@ test "implicit cast packed struct field to const ptr" {
536535}
537536
538537test "zero-bit field in packed struct" {
539 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
540538 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
541539
542540 const S = packed struct {
......@@ -719,7 +717,6 @@ test "pointer to packed struct member in a stack variable" {
719717}
720718
721719test "packed struct with u0 field access" {
722 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
723720 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
724721
725722 const S = packed struct {
......@@ -1018,7 +1015,6 @@ test "type coercion of anon struct literal to struct" {
10181015}
10191016
10201017test "type coercion of pointer to anon struct literal to pointer to struct" {
1021 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10221018 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10231019 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10241020 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1088,7 +1084,6 @@ test "packed struct with undefined initializers" {
10881084}
10891085
10901086test "for loop over pointers to struct, getting field from struct pointer" {
1091 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10921087 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10931088 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10941089
test/behavior/struct_contains_null_ptr_itself.zig-1
......@@ -4,7 +4,6 @@ const builtin = @import("builtin");
44
55test "struct contains null pointer which contains original struct" {
66 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98
109 var x: ?*NodeLineComment = null;
test/behavior/switch.zig-2
......@@ -403,7 +403,6 @@ fn return_a_number() anyerror!i32 {
403403}
404404
405405test "switch on integer with else capturing expr" {
406 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
407406 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
408407
409408 const S = struct {
......@@ -577,7 +576,6 @@ test "switch prongs with cases with identical payload types" {
577576}
578577
579578test "switch on pointer type" {
580 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
581579 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
582580 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
583581
test/behavior/threadlocal.zig-2
......@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44
55test "thread local variable" {
66 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
7 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
98 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
109 if (builtin.zig_backend == .stage2_llvm) switch (builtin.cpu.arch) {
......@@ -40,7 +39,6 @@ threadlocal var buffer: [11]u8 = undefined;
4039
4140test "reference a global threadlocal variable" {
4241 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
43 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
4442 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
4543 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
4644 if (builtin.zig_backend == .stage2_llvm) switch (builtin.cpu.arch) {
test/behavior/translate_c_macros.zig-1
......@@ -79,7 +79,6 @@ test "casting to union with a macro" {
7979
8080test "casting or calling a value with a paren-surrounded macro" {
8181 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
82 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
8382 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8483 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8584 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/tuple.zig-1
......@@ -126,7 +126,6 @@ test "tuple initializer for var" {
126126}
127127
128128test "array-like initializer for tuple types" {
129 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
130129 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
131130 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
132131
test/behavior/type.zig-4
......@@ -449,8 +449,6 @@ test "Type.Union" {
449449}
450450
451451test "Type.Union from Type.Enum" {
452 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
453
454452 const Tag = @Type(.{
455453 .Enum = .{
456454 .tag_type = u0,
......@@ -475,8 +473,6 @@ test "Type.Union from Type.Enum" {
475473}
476474
477475test "Type.Union from regular enum" {
478 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
479
480476 const E = enum { working_as_expected };
481477 const T = @Type(.{
482478 .Union = .{
test/behavior/type_info.zig-2
......@@ -509,7 +509,6 @@ test "type info for async frames" {
509509}
510510
511511test "Declarations are returned in declaration order" {
512 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
513512 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
514513
515514 const S = struct {
......@@ -532,7 +531,6 @@ test "Struct.is_tuple for anon list literal" {
532531}
533532
534533test "Struct.is_tuple for anon struct literal" {
535 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
536534 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
537535
538536 const info = @typeInfo(@TypeOf(.{ .a = 0 }));
test/behavior/union.zig-11
......@@ -11,7 +11,6 @@ const FooWithFloats = union {
1111};
1212
1313test "basic unions with floats" {
14 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1514 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1615 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1716 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -215,7 +214,6 @@ const Payload = union(Letter) {
215214};
216215
217216test "union with specified enum tag" {
218 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
219217 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
220218 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
221219 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -225,7 +223,6 @@ test "union with specified enum tag" {
225223}
226224
227225test "packed union generates correctly aligned type" {
228 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
229226 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
230227 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
231228 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -379,7 +376,6 @@ test "union with only 1 field which is void should be zero bits" {
379376}
380377
381378test "tagged union initialization with runtime void" {
382 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
383379 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
384380 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
385381 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -400,7 +396,6 @@ fn testTaggedUnionInit(x: anytype) bool {
400396pub const UnionEnumNoPayloads = union(enum) { A, B };
401397
402398test "tagged union with no payloads" {
403 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
404399 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
405400 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
406401 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -466,7 +461,6 @@ pub const FooUnion = union(enum) {
466461var glbl_array: [2]FooUnion = undefined;
467462
468463test "initialize global array of union" {
469 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
470464 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
471465 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
472466 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -494,7 +488,6 @@ test "update the tag value for zero-sized unions" {
494488
495489test "union initializer generates padding only if needed" {
496490 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
497 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
498491 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
499492 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
500493 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -561,7 +554,6 @@ const FooNoVoid = union(enum) {
561554const Baz = enum { A, B, C, D };
562555
563556test "tagged union type" {
564 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
565557 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
566558
567559 const foo1 = TaggedFoo{ .One = 13 };
......@@ -598,7 +590,6 @@ fn returnAnInt(x: i32) TaggedFoo {
598590}
599591
600592test "tagged union with all void fields but a meaningful tag" {
601 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
602593 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
603594 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
604595 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -777,7 +768,6 @@ fn Setter(comptime attr: Attribute) type {
777768}
778769
779770test "return union init with void payload" {
780 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
781771 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
782772 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
783773 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
......@@ -913,7 +903,6 @@ test "extern union doesn't trigger field check at comptime" {
913903test "anonymous union literal syntax" {
914904 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
915905 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
916 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
917906 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
918907
919908 const S = struct {
test/behavior/union_with_members.zig-1
......@@ -18,7 +18,6 @@ const ET = union(enum) {
1818
1919test "enum with members" {
2020 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
21 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
2221 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
2322 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
2423 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/vector.zig-6
......@@ -382,7 +382,6 @@ test "store vector elements via runtime index" {
382382}
383383
384384test "initialize vector which is a struct field" {
385 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
386385 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
387386 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
388387 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -794,7 +793,6 @@ test "vector reduce operation" {
794793
795794test "vector @reduce comptime" {
796795 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
797 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
798796 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
799797 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
800798 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1069,7 +1067,6 @@ test "alignment of vectors" {
10691067
10701068test "loading the second vector from a slice of vectors" {
10711069 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1072 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10731070 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10741071 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10751072 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1150,7 +1147,6 @@ test "byte vector initialized in inline function" {
11501147
11511148test "zero divisor" {
11521149 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1153 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11541150 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11551151 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11561152 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1171,7 +1167,6 @@ test "zero divisor" {
11711167
11721168test "zero multiplicand" {
11731169 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1174 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11751170 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11761171 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11771172 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -1234,7 +1229,6 @@ test "load packed vector element" {
12341229 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12351230 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12361231 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1237 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
12381232
12391233 var x: @Vector(2, u15) = .{ 1, 4 };
12401234 try expect((&x[0]).* == 1);
test/behavior/void.zig-1
......@@ -33,7 +33,6 @@ fn times(n: usize) []const void {
3333}
3434
3535test "void optional" {
36 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
3736 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3837 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3938 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/while.zig-8
......@@ -104,7 +104,6 @@ fn testBreakOuter() void {
104104}
105105
106106test "while copies its payload" {
107 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
108107 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109108 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
110109
......@@ -143,7 +142,6 @@ fn runContinueAndBreakTest() !void {
143142}
144143
145144test "while with optional as condition" {
146 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
147145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
148146 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
149147
......@@ -156,7 +154,6 @@ test "while with optional as condition" {
156154}
157155
158156test "while with optional as condition with else" {
159 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
160157 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161158 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162159
......@@ -174,7 +171,6 @@ test "while with optional as condition with else" {
174171}
175172
176173test "while with error union condition" {
177 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
178174 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
179175
180176 numbers_left = 10;
......@@ -205,7 +201,6 @@ test "while on bool with else result follow break prong" {
205201}
206202
207203test "while on optional with else result follow else prong" {
208 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
209204 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
210205 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
211206 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -217,7 +212,6 @@ test "while on optional with else result follow else prong" {
217212}
218213
219214test "while on optional with else result follow break prong" {
220 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
221215 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
222216 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
223217 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -290,7 +284,6 @@ test "while bool 2 break statements and an else" {
290284}
291285
292286test "while optional 2 break statements and an else" {
293 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
294287 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
295288 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
296289 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
......@@ -310,7 +303,6 @@ test "while optional 2 break statements and an else" {
310303}
311304
312305test "while error 2 break statements and an else" {
313 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
314306 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
315307 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
316308 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/behavior/widening.zig-1
......@@ -28,7 +28,6 @@ test "integer widening u0 to u8" {
2828}
2929
3030test "implicit unsigned integer to signed integer" {
31 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
3231 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
3332 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
3433
tools/lldb_pretty_printers.py+1-1
......@@ -1,6 +1,6 @@
11# pretty printing for the zig language, zig standard library, and zig stage 2 compiler.
22# put commands in ~/.lldbinit to run them automatically when starting lldb
3# `command script /path/to/stage2_lldb_pretty_printers.py` to import this file
3# `command script import /path/to/zig/tools/lldb_pretty_printers.py` to import this file
44# `type category enable zig` to enable pretty printing for the zig language
55# `type category enable zig.std` to enable pretty printing for the zig standard library
66# `type category enable zig.stage2` to enable pretty printing for the zig stage 2 compiler