Commit cffbb32d31495c83addae7ed3882dc000fb327aa | zig

author	Andrew Kelley <andrew@ziglang.org> 2022-12-10 15:10:21-05:00
committer	GitHub <noreply@github.com> 2022-12-10 15:10:21-05:00
log	cffbb32d31495c83addae7ed3882dc000fb327aa
tree	0f3c54e01f5384a064b0efbfc68d65ba982bb77e
parent	f1f17dc1c744defa89f65b2dc642ca0c1b7c1e44
parent	f9e9ba784f508e1b571a2fb64b55ad58c6ec74c8
signature	Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #13872 from koachan/sparc64-codegen

stage2: sparc64: Some Air lowerings + skip unbuildable tests

135 files changed, 1248 insertions(+), 41 deletions(-)

src
- arch
  - sparc64
    CodeGen.zig
test
- behavior

src/arch/sparc64/CodeGen.zig+383-41

...	...	@@ -144,6 +144,7 @@ const MCValue = union(enum) {
144	144	memory: u64,
145	145	/// The value is one of the stack variables.
146	146	/// If the type is a pointer, it means the pointer address is in the stack at this offset.
	147	/// Note that this stores the plain value (i.e without the effects of the stack bias).
147	148	stack_offset: u32,
148	149	/// The value is a pointer to one of the stack variables (payload is stack offset).
149	150	ptr_stack_offset: u32,
...	...	@@ -274,6 +275,8 @@ pub fn generate(
274	275	assert(fn_owner_decl.has_tv);
275	276	const fn_type = fn_owner_decl.ty;
276	277
	278	log.debug("fn {s}", .{fn_owner_decl.name});
	279
277	280	var branch_stack = std.ArrayList(Branch).init(bin_file.allocator);
278	281	defer {
279	282	assert(branch_stack.items.len == 1);
...	...	@@ -518,8 +521,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
518	521	.sub_sat => try self.airSubSat(inst),
519	522	.mul_sat => try self.airMulSat(inst),
520	523	.shl_sat => try self.airShlSat(inst),
521		.min => @panic("TODO try self.airMin(inst)"),
522		.max => @panic("TODO try self.airMax(inst)"),
	524	.min, .max => try self.airMinMax(inst),
523	525	.rem => try self.airRem(inst),
524	526	.mod => try self.airMod(inst),
525	527	.slice => try self.airSlice(inst),
...	...	@@ -573,7 +575,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
573	575	.fptrunc => @panic("TODO try self.airFptrunc(inst)"),
574	576	.fpext => @panic("TODO try self.airFpext(inst)"),
575	577	.intcast => try self.airIntCast(inst),
576		.trunc => @panic("TODO try self.airTrunc(inst)"),
	578	.trunc => try self.airTrunc(inst),
577	579	.bool_to_int => try self.airBoolToInt(inst),
578	580	.is_non_null => try self.airIsNonNull(inst),
579	581	.is_non_null_ptr => @panic("TODO try self.airIsNonNullPtr(inst)"),
...	...	@@ -595,27 +597,28 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
595	597	.array_to_slice => try self.airArrayToSlice(inst),
596	598	.int_to_float => try self.airIntToFloat(inst),
597	599	.float_to_int => try self.airFloatToInt(inst),
598		.cmpxchg_strong => @panic("TODO try self.airCmpxchg(inst)"),
599		.cmpxchg_weak => @panic("TODO try self.airCmpxchg(inst)"),
600		.atomic_rmw => @panic("TODO try self.airAtomicRmw(inst)"),
601		.atomic_load => @panic("TODO try self.airAtomicLoad(inst)"),
	600	.cmpxchg_strong,
	601	.cmpxchg_weak,
	602	=> try self.airCmpxchg(inst),
	603	.atomic_rmw => try self.airAtomicRmw(inst),
	604	.atomic_load => try self.airAtomicLoad(inst),
602	605	.memcpy => @panic("TODO try self.airMemcpy(inst)"),
603	606	.memset => try self.airMemset(inst),
604		.set_union_tag => @panic("TODO try self.airSetUnionTag(inst)"),
605		.get_union_tag => @panic("TODO try self.airGetUnionTag(inst)"),
	607	.set_union_tag => try self.airSetUnionTag(inst),
	608	.get_union_tag => try self.airGetUnionTag(inst),
606	609	.clz => try self.airClz(inst),
607	610	.ctz => try self.airCtz(inst),
608	611	.popcount => try self.airPopcount(inst),
609	612	.byte_swap => @panic("TODO try self.airByteSwap(inst)"),
610		.bit_reverse => @panic("TODO try self.airBitReverse(inst)"),
	613	.bit_reverse => try self.airBitReverse(inst),
611	614	.tag_name => try self.airTagName(inst),
612		.error_name => @panic("TODO try self.airErrorName(inst)"),
613		.splat => @panic("TODO try self.airSplat(inst)"),
	615	.error_name => try self.airErrorName(inst),
	616	.splat => try self.airSplat(inst),
614	617	.select => @panic("TODO try self.airSelect(inst)"),
615	618	.shuffle => @panic("TODO try self.airShuffle(inst)"),
616	619	.reduce => @panic("TODO try self.airReduce(inst)"),
617	620	.aggregate_init => try self.airAggregateInit(inst),
618		.union_init => @panic("TODO try self.airUnionInit(inst)"),
	621	.union_init => try self.airUnionInit(inst),
619	622	.prefetch => try self.airPrefetch(inst),
620	623	.mul_add => @panic("TODO try self.airMulAdd(inst)"),
621	624	.addrspace_cast => @panic("TODO try self.airAddrSpaceCast(int)"),
...	...	@@ -682,7 +685,7 @@ fn genBody(self: *Self, body: []const Air.Inst.Index) InnerError!void {
682	685	.save_err_return_trace_index=> @panic("TODO try self.airSaveErrReturnTraceIndex(inst)"),
683	686
684	687	.wrap_optional => try self.airWrapOptional(inst),
685		.wrap_errunion_payload => @panic("TODO try self.airWrapErrUnionPayload(inst)"),
	688	.wrap_errunion_payload => try self.airWrapErrUnionPayload(inst),
686	689	.wrap_errunion_err => try self.airWrapErrUnionErr(inst),
687	690
688	691	.add_optimized,
...	...	@@ -991,12 +994,21 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
991	994	self.arg_index += 1;
992	995
993	996	const ty = self.air.typeOfIndex(inst);
994		_ = ty;
995	997
996		const result = self.args[arg_index];
997		// TODO support stack-only arguments
998		// TODO Copy registers to the stack
999		const mcv = result;
	998	const arg = self.args[arg_index];
	999	const mcv = blk: {
	1000	switch (arg) {
	1001	.stack_offset => \|off\| {
	1002	const mod = self.bin_file.options.module.?;
	1003	const abi_size = math.cast(u32, ty.abiSize(self.target.*)) orelse {
	1004	return self.fail("type '{}' too big to fit into stack frame", .{ty.fmt(mod)});
	1005	};
	1006	const offset = off + abi_size;
	1007	break :blk MCValue{ .stack_offset = offset };
	1008	},
	1009	else => break :blk arg,
	1010	}
	1011	};
1000	1012
1001	1013	try self.genArgDbgInfo(inst, mcv, @intCast(u32, arg_index));
1002	1014
...	...	@@ -1013,6 +1025,22 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
1013	1025	return self.finishAir(inst, mcv, .{ .none, .none, .none });
1014	1026	}
1015	1027
	1028	fn airAtomicLoad(self: *Self, inst: Air.Inst.Index) !void {
	1029	_ = self.air.instructions.items(.data)[inst].atomic_load;
	1030
	1031	return self.fail("TODO implement airAtomicLoad for {}", .{
	1032	self.target.cpu.arch,
	1033	});
	1034	}
	1035
	1036	fn airAtomicRmw(self: *Self, inst: Air.Inst.Index) !void {
	1037	_ = self.air.instructions.items(.data)[inst].pl_op;
	1038
	1039	return self.fail("TODO implement airAtomicRmw for {}", .{
	1040	self.target.cpu.arch,
	1041	});
	1042	}
	1043
1016	1044	fn airBinOp(self: *Self, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void {
1017	1045	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
1018	1046	const lhs = try self.resolveInst(bin_op.lhs);
...	...	@@ -1061,6 +1089,12 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
1061	1089	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1062	1090	}
1063	1091
	1092	fn airBitReverse(self: *Self, inst: Air.Inst.Index) !void {
	1093	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	1094	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airBitReverse for {}", .{self.target.cpu.arch});
	1095	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	1096	}
	1097
1064	1098	fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
1065	1099	try self.blocks.putNoClobber(self.gpa, inst, .{
1066	1100	// A block is a setup to be able to jump to the end.
...	...	@@ -1322,6 +1356,16 @@ fn airCmpLtErrorsLen(self: *Self, inst: Air.Inst.Index) !void {
1322	1356	return self.finishAir(inst, result, .{ un_op, .none, .none });
1323	1357	}
1324	1358
	1359	fn airCmpxchg(self: *Self, inst: Air.Inst.Index) !void {
	1360	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
	1361	const extra = self.air.extraData(Air.Block, ty_pl.payload);
	1362	_ = extra;
	1363
	1364	return self.fail("TODO implement airCmpxchg for {}", .{
	1365	self.target.cpu.arch,
	1366	});
	1367	}
	1368
1325	1369	fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
1326	1370	const pl_op = self.air.instructions.items(.data)[inst].pl_op;
1327	1371	const condition = try self.resolveInst(pl_op.operand);
...	...	@@ -1406,6 +1450,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
1406	1450	const else_value = else_values[else_idx];
1407	1451	const canon_mcv = if (saved_then_branch.inst_table.fetchSwapRemove(else_key)) \|then_entry\| blk: {
1408	1452	// The instruction's MCValue is overridden in both branches.
	1453	log.debug("condBr put branch table (key = %{d}, value = {})", .{ else_key, then_entry.value });
1409	1454	parent_branch.inst_table.putAssumeCapacity(else_key, then_entry.value);
1410	1455	if (else_value == .dead) {
1411	1456	assert(then_entry.value == .dead);
...	...	@@ -1519,6 +1564,16 @@ fn airDiv(self: *Self, inst: Air.Inst.Index) !void {
1519	1564	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
1520	1565	}
1521	1566
	1567	fn airErrorName(self: *Self, inst: Air.Inst.Index) !void {
	1568	const un_op = self.air.instructions.items(.data)[inst].un_op;
	1569	const operand = try self.resolveInst(un_op);
	1570	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else {
	1571	_ = operand;
	1572	return self.fail("TODO implement airErrorName for {}", .{self.target.cpu.arch});
	1573	};
	1574	return self.finishAir(inst, result, .{ un_op, .none, .none });
	1575	}
	1576
1522	1577	fn airErrUnionPayloadPtrSet(self: *Self, inst: Air.Inst.Index) !void {
1523	1578	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1524	1579	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement .errunion_payload_ptr_set for {}", .{self.target.cpu.arch});
...	...	@@ -1556,6 +1611,12 @@ fn airFloatToInt(self: *Self, inst: Air.Inst.Index) !void {
1556	1611	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1557	1612	}
1558	1613
	1614	fn airGetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
	1615	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	1616	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airGetUnionTag for {}", .{self.target.cpu.arch});
	1617	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	1618	}
	1619
1559	1620	fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
1560	1621	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1561	1622	if (self.liveness.isUnused(inst))
...	...	@@ -1675,6 +1736,22 @@ fn airMemset(self: *Self, inst: Air.Inst.Index) !void {
1675	1736	return self.fail("TODO implement airMemset for {}", .{self.target.cpu.arch});
1676	1737	}
1677	1738
	1739	fn airMinMax(self: *Self, inst: Air.Inst.Index) !void {
	1740	const tag = self.air.instructions.items(.tag)[inst];
	1741	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
	1742	const lhs = try self.resolveInst(bin_op.lhs);
	1743	const rhs = try self.resolveInst(bin_op.rhs);
	1744	const lhs_ty = self.air.typeOf(bin_op.lhs);
	1745	const rhs_ty = self.air.typeOf(bin_op.rhs);
	1746
	1747	const result: MCValue = if (self.liveness.isUnused(inst))
	1748	.dead
	1749	else
	1750	try self.minMax(tag, lhs, rhs, lhs_ty, rhs_ty);
	1751
	1752	return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
	1753	}
	1754
1678	1755	fn airMod(self: *Self, inst: Air.Inst.Index) !void {
1679	1756	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
1680	1757	const lhs = try self.resolveInst(bin_op.lhs);
...	...	@@ -2071,6 +2148,12 @@ fn airRetPtr(self: *Self, inst: Air.Inst.Index) !void {
2071	2148	return self.finishAir(inst, .{ .ptr_stack_offset = stack_offset }, .{ .none, .none, .none });
2072	2149	}
2073	2150
	2151	fn airSetUnionTag(self: *Self, inst: Air.Inst.Index) !void {
	2152	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
	2153	_ = bin_op;
	2154	return self.fail("TODO implement airSetUnionTag for {}", .{self.target.cpu.arch});
	2155	}
	2156
2074	2157	fn airShlSat(self: *Self, inst: Air.Inst.Index) !void {
2075	2158	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2076	2159	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement shl_sat for {}", .{self.target.cpu.arch});
...	...	@@ -2270,6 +2353,12 @@ fn airSlicePtr(self: *Self, inst: Air.Inst.Index) !void {
2270	2353	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2271	2354	}
2272	2355
	2356	fn airSplat(self: *Self, inst: Air.Inst.Index) !void {
	2357	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2358	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airSplat for {}", .{self.target.cpu.arch});
	2359	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	2360	}
	2361
2273	2362	fn airStore(self: *Self, inst: Air.Inst.Index) !void {
2274	2363	const bin_op = self.air.instructions.items(.data)[inst].bin_op;
2275	2364	const ptr = try self.resolveInst(bin_op.lhs);
...	...	@@ -2378,6 +2467,19 @@ fn airTagName(self: *Self, inst: Air.Inst.Index) !void {
2378	2467	return self.finishAir(inst, result, .{ un_op, .none, .none });
2379	2468	}
2380	2469
	2470	fn airTrunc(self: *Self, inst: Air.Inst.Index) !void {
	2471	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2472	const operand = try self.resolveInst(ty_op.operand);
	2473	const operand_ty = self.air.typeOf(ty_op.operand);
	2474	const dest_ty = self.air.typeOfIndex(inst);
	2475
	2476	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else blk: {
	2477	break :blk try self.trunc(inst, operand, operand_ty, dest_ty);
	2478	};
	2479
	2480	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	2481	}
	2482
2381	2483	fn airTry(self: *Self, inst: Air.Inst.Index) !void {
2382	2484	const pl_op = self.air.instructions.items(.data)[inst].pl_op;
2383	2485	const extra = self.air.extraData(Air.Try, pl_op.payload);
...	...	@@ -2405,6 +2507,13 @@ fn airUnaryMath(self: *Self, inst: Air.Inst.Index) !void {
2405	2507	return self.finishAir(inst, result, .{ un_op, .none, .none });
2406	2508	}
2407	2509
	2510	fn airUnionInit(self: *Self, inst: Air.Inst.Index) !void {
	2511	const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
	2512	const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
	2513	_ = extra;
	2514	return self.fail("TODO implement airUnionInit for {}", .{self.target.cpu.arch});
	2515	}
	2516
2408	2517	fn airUnwrapErrErr(self: *Self, inst: Air.Inst.Index) !void {
2409	2518	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2410	2519	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
...	...	@@ -2444,6 +2553,13 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
2444	2553	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
2445	2554	}
2446	2555
	2556	/// T to E!T
	2557	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
	2558	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	2559	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});
	2560	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	2561	}
	2562
2447	2563	fn airWrapOptional(self: *Self, inst: Air.Inst.Index) !void {
2448	2564	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
2449	2565	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
...	...	@@ -2843,7 +2959,18 @@ fn binOpImmediate(
2843	2959
2844	2960	const reg = try self.register_manager.allocReg(track_inst, gp);
2845	2961
2846		if (track_inst) \|inst\| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
	2962	if (track_inst) \|inst\| {
	2963	const mcv = .{ .register = reg };
	2964	log.debug("binOpRegister move lhs %{d} to register: {} -> {}", .{ inst, lhs, mcv });
	2965	branch.inst_table.putAssumeCapacity(inst, mcv);
	2966
	2967	// If we're moving a condition flag MCV to register,
	2968	// mark it as free.
	2969	if (lhs == .condition_flags) {
	2970	assert(self.condition_flags_inst.? == inst);
	2971	self.condition_flags_inst = null;
	2972	}
	2973	}
2847	2974
2848	2975	break :blk reg;
2849	2976	};
...	...	@@ -2970,7 +3097,18 @@ fn binOpRegister(
2970	3097	} else null;
2971	3098
2972	3099	const reg = try self.register_manager.allocReg(track_inst, gp);
2973		if (track_inst) \|inst\| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
	3100	if (track_inst) \|inst\| {
	3101	const mcv = .{ .register = reg };
	3102	log.debug("binOpRegister move lhs %{d} to register: {} -> {}", .{ inst, lhs, mcv });
	3103	branch.inst_table.putAssumeCapacity(inst, mcv);
	3104
	3105	// If we're moving a condition flag MCV to register,
	3106	// mark it as free.
	3107	if (lhs == .condition_flags) {
	3108	assert(self.condition_flags_inst.? == inst);
	3109	self.condition_flags_inst = null;
	3110	}
	3111	}
2974	3112
2975	3113	break :blk reg;
2976	3114	};
...	...	@@ -2983,7 +3121,18 @@ fn binOpRegister(
2983	3121	} else null;
2984	3122
2985	3123	const reg = try self.register_manager.allocReg(track_inst, gp);
2986		if (track_inst) \|inst\| branch.inst_table.putAssumeCapacity(inst, .{ .register = reg });
	3124	if (track_inst) \|inst\| {
	3125	const mcv = .{ .register = reg };
	3126	log.debug("binOpRegister move rhs %{d} to register: {} -> {}", .{ inst, rhs, mcv });
	3127	branch.inst_table.putAssumeCapacity(inst, mcv);
	3128
	3129	// If we're moving a condition flag MCV to register,
	3130	// mark it as free.
	3131	if (rhs == .condition_flags) {
	3132	assert(self.condition_flags_inst.? == inst);
	3133	self.condition_flags_inst = null;
	3134	}
	3135	}
2987	3136
2988	3137	break :blk reg;
2989	3138	};
...	...	@@ -3734,27 +3883,48 @@ fn genStore(self: *Self, value_reg: Register, addr_reg: Register, comptime off_t
3734	3883	}
3735	3884
3736	3885	fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
3737		if (typed_value.val.isUndef())
	3886	var tv = typed_value;
	3887	log.debug("genTypedValue: ty = {}, val = {}", .{ tv.ty.fmtDebug(), tv.val.fmtDebug() });
	3888
	3889	if (tv.val.castTag(.runtime_value)) \|rt\| {
	3890	tv.val = rt.data;
	3891	}
	3892
	3893	if (tv.val.isUndef())
3738	3894	return MCValue{ .undef = {} };
3739	3895
3740		if (typed_value.val.castTag(.decl_ref)) \|payload\| {
3741		return self.lowerDeclRef(typed_value, payload.data);
	3896	if (tv.val.castTag(.decl_ref)) \|payload\| {
	3897	return self.lowerDeclRef(tv, payload.data);
3742	3898	}
3743		if (typed_value.val.castTag(.decl_ref_mut)) \|payload\| {
3744		return self.lowerDeclRef(typed_value, payload.data.decl_index);
	3899	if (tv.val.castTag(.decl_ref_mut)) \|payload\| {
	3900	return self.lowerDeclRef(tv, payload.data.decl_index);
3745	3901	}
3746	3902	const target = self.target.*;
3747	3903
3748		switch (typed_value.ty.zigTypeTag()) {
	3904	switch (tv.ty.zigTypeTag()) {
	3905	.Pointer => switch (tv.ty.ptrSize()) {
	3906	.Slice => {},
	3907	else => {
	3908	switch (tv.val.tag()) {
	3909	.int_u64 => {
	3910	return MCValue{ .immediate = tv.val.toUnsignedInt(target) };
	3911	},
	3912	else => {},
	3913	}
	3914	},
	3915	},
	3916	.Bool => {
	3917	return MCValue{ .immediate = @boolToInt(tv.val.toBool()) };
	3918	},
3749	3919	.Int => {
3750		const info = typed_value.ty.intInfo(self.target.*);
	3920	const info = tv.ty.intInfo(self.target.*);
3751	3921	if (info.bits <= 64) {
3752	3922	const unsigned = switch (info.signedness) {
3753	3923	.signed => blk: {
3754		const signed = typed_value.val.toSignedInt(target);
	3924	const signed = tv.val.toSignedInt(target);
3755	3925	break :blk @bitCast(u64, signed);
3756	3926	},
3757		.unsigned => typed_value.val.toUnsignedInt(target),
	3927	.unsigned => tv.val.toUnsignedInt(target),
3758	3928	};
3759	3929
3760	3930	return MCValue{ .immediate = unsigned };
...	...	@@ -3762,38 +3932,84 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
3762	3932	return self.fail("TODO implement int genTypedValue of > 64 bits", .{});
3763	3933	}
3764	3934	},
	3935	.Optional => {
	3936	if (tv.ty.isPtrLikeOptional()) {
	3937	if (tv.val.isNull())
	3938	return MCValue{ .immediate = 0 };
	3939
	3940	var buf: Type.Payload.ElemType = undefined;
	3941	return self.genTypedValue(.{
	3942	.ty = tv.ty.optionalChild(&buf),
	3943	.val = tv.val,
	3944	});
	3945	} else if (tv.ty.abiSize(self.target.*) == 1) {
	3946	return MCValue{ .immediate = @boolToInt(tv.val.isNull()) };
	3947	}
	3948	},
	3949	.Enum => {
	3950	if (tv.val.castTag(.enum_field_index)) \|field_index\| {
	3951	switch (tv.ty.tag()) {
	3952	.enum_simple => {
	3953	return MCValue{ .immediate = field_index.data };
	3954	},
	3955	.enum_full, .enum_nonexhaustive => {
	3956	const enum_full = tv.ty.cast(Type.Payload.EnumFull).?.data;
	3957	if (enum_full.values.count() != 0) {
	3958	const tag_val = enum_full.values.keys()[field_index.data];
	3959	return self.genTypedValue(.{ .ty = enum_full.tag_ty, .val = tag_val });
	3960	} else {
	3961	return MCValue{ .immediate = field_index.data };
	3962	}
	3963	},
	3964	else => unreachable,
	3965	}
	3966	} else {
	3967	var int_tag_buffer: Type.Payload.Bits = undefined;
	3968	const int_tag_ty = tv.ty.intTagType(&int_tag_buffer);
	3969	return self.genTypedValue(.{ .ty = int_tag_ty, .val = tv.val });
	3970	}
	3971	},
3765	3972	.ErrorSet => {
3766		const err_name = typed_value.val.castTag(.@"error").?.data.name;
	3973	const err_name = tv.val.castTag(.@"error").?.data.name;
3767	3974	const module = self.bin_file.options.module.?;
3768	3975	const global_error_set = module.global_error_set;
3769	3976	const error_index = global_error_set.get(err_name).?;
3770	3977	return MCValue{ .immediate = error_index };
3771	3978	},
3772	3979	.ErrorUnion => {
3773		const error_type = typed_value.ty.errorUnionSet();
3774		const payload_type = typed_value.ty.errorUnionPayload();
	3980	const error_type = tv.ty.errorUnionSet();
	3981	const payload_type = tv.ty.errorUnionPayload();
3775	3982
3776		if (typed_value.val.castTag(.eu_payload)) \|pl\| {
	3983	if (tv.val.castTag(.eu_payload)) \|pl\| {
3777	3984	if (!payload_type.hasRuntimeBits()) {
3778	3985	// We use the error type directly as the type.
3779	3986	return MCValue{ .immediate = 0 };
3780	3987	}
3781	3988
3782	3989	_ = pl;
3783		return self.fail("TODO implement error union const of type '{}' (non-error)", .{typed_value.ty.fmtDebug()});
	3990	return self.fail("TODO implement error union const of type '{}' (non-error)", .{tv.ty.fmtDebug()});
3784	3991	} else {
3785	3992	if (!payload_type.hasRuntimeBits()) {
3786	3993	// We use the error type directly as the type.
3787		return self.genTypedValue(.{ .ty = error_type, .val = typed_value.val });
	3994	return self.genTypedValue(.{ .ty = error_type, .val = tv.val });
3788	3995	}
3789	3996
3790		return self.fail("TODO implement error union const of type '{}' (error)", .{typed_value.ty.fmtDebug()});
	3997	return self.fail("TODO implement error union const of type '{}' (error)", .{tv.ty.fmtDebug()});
3791	3998	}
3792	3999	},
3793	4000	.ComptimeInt => unreachable, // semantic analysis prevents this
3794	4001	.ComptimeFloat => unreachable, // semantic analysis prevents this
3795		else => return self.fail("TODO implement const of type '{}'", .{typed_value.ty.fmtDebug()}),
	4002	.Type => unreachable,
	4003	.EnumLiteral => unreachable,
	4004	.Void => unreachable,
	4005	.NoReturn => unreachable,
	4006	.Undefined => unreachable,
	4007	.Null => unreachable,
	4008	.Opaque => unreachable,
	4009	else => {},
3796	4010	}
	4011
	4012	return self.fail("TODO implement const of type '{}'", .{tv.ty.fmtDebug()});
3797	4013	}
3798	4014
3799	4015	fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) MCValue {
...	...	@@ -3802,6 +4018,7 @@ fn getResolvedInstValue(self: *Self, inst: Air.Inst.Index) MCValue {
3802	4018	while (true) {
3803	4019	i -= 1;
3804	4020	if (self.branch_stack.items[i].inst_table.get(inst)) \|mcv\| {
	4021	log.debug("getResolvedInstValue %{} => {}", .{ inst, mcv });
3805	4022	assert(mcv != .dead);
3806	4023	return mcv;
3807	4024	}
...	...	@@ -3993,6 +4210,83 @@ fn lowerDeclRef(self: *Self, tv: TypedValue, decl_index: Module.Decl.Index) Inne
3993	4210	}
3994	4211	}
3995	4212
	4213	fn minMax(
	4214	self: *Self,
	4215	tag: Air.Inst.Tag,
	4216	lhs: MCValue,
	4217	rhs: MCValue,
	4218	lhs_ty: Type,
	4219	rhs_ty: Type,
	4220	) InnerError!MCValue {
	4221	const mod = self.bin_file.options.module.?;
	4222	assert(lhs_ty.eql(rhs_ty, mod));
	4223	switch (lhs_ty.zigTypeTag()) {
	4224	.Float => return self.fail("TODO min/max on floats", .{}),
	4225	.Vector => return self.fail("TODO min/max on vectors", .{}),
	4226	.Int => {
	4227	const int_info = lhs_ty.intInfo(self.target.*);
	4228	if (int_info.bits <= 64) {
	4229	// TODO skip register setting when one of the operands
	4230	// is a small (fits in i13) immediate.
	4231	const rhs_is_register = rhs == .register;
	4232	const rhs_reg = if (rhs_is_register)
	4233	rhs.register
	4234	else
	4235	try self.register_manager.allocReg(null, gp);
	4236	const rhs_lock = self.register_manager.lockReg(rhs_reg);
	4237	defer if (rhs_lock) \|reg\| self.register_manager.unlockReg(reg);
	4238	if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
	4239
	4240	const result_reg = try self.register_manager.allocReg(null, gp);
	4241	const result_lock = self.register_manager.lockReg(result_reg);
	4242	defer if (result_lock) \|reg\| self.register_manager.unlockReg(reg);
	4243	try self.genSetReg(lhs_ty, result_reg, lhs);
	4244
	4245	const cond_choose_rhs: Instruction.ICondition = switch (tag) {
	4246	.max => switch (int_info.signedness) {
	4247	.signed => Instruction.ICondition.gt,
	4248	.unsigned => Instruction.ICondition.gu,
	4249	},
	4250	.min => switch (int_info.signedness) {
	4251	.signed => Instruction.ICondition.lt,
	4252	.unsigned => Instruction.ICondition.cs,
	4253	},
	4254	else => unreachable,
	4255	};
	4256
	4257	_ = try self.addInst(.{
	4258	.tag = .cmp,
	4259	.data = .{
	4260	.arithmetic_2op = .{
	4261	.is_imm = false,
	4262	.rs1 = result_reg,
	4263	.rs2_or_imm = .{ .rs2 = rhs_reg },
	4264	},
	4265	},
	4266	});
	4267
	4268	_ = try self.addInst(.{
	4269	.tag = .movcc,
	4270	.data = .{
	4271	.conditional_move_int = .{
	4272	.is_imm = false,
	4273	.ccr = .xcc,
	4274	.cond = .{ .icond = cond_choose_rhs },
	4275	.rd = result_reg,
	4276	.rs2_or_imm = .{ .rs2 = rhs_reg },
	4277	},
	4278	},
	4279	});
	4280
	4281	return MCValue{ .register = result_reg };
	4282	} else {
	4283	return self.fail("TODO min/max on integers > u64/i64", .{});
	4284	}
	4285	},
	4286	else => unreachable,
	4287	}
	4288	}
	4289
3996	4290	fn parseRegName(name: []const u8) ?Register {
3997	4291	if (@hasDecl(Register, "parseRegName")) {
3998	4292	return Register.parseRegName(name);
...	...	@@ -4017,6 +4311,7 @@ fn processDeath(self: *Self, inst: Air.Inst.Index) void {
4017	4311	const prev_value = self.getResolvedInstValue(inst);
4018	4312	const branch = &self.branch_stack.items[self.branch_stack.items.len - 1];
4019	4313	branch.inst_table.putAssumeCapacity(inst, .dead);
	4314	log.debug("%{} death: {} -> .dead", .{ inst, prev_value });
4020	4315	switch (prev_value) {
4021	4316	.register => \|reg\| {
4022	4317	self.register_manager.freeReg(reg);
...	...	@@ -4126,7 +4421,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
4126	4421	const ref_int = @enumToInt(inst);
4127	4422	if (ref_int < Air.Inst.Ref.typed_value_map.len) {
4128	4423	const tv = Air.Inst.Ref.typed_value_map[ref_int];
4129		if (!tv.ty.hasRuntimeBits() and !tv.ty.isError()) {
	4424	if (!tv.ty.hasRuntimeBitsIgnoreComptime() and !tv.ty.isError()) {
4130	4425	return MCValue{ .none = {} };
4131	4426	}
4132	4427	return self.genTypedValue(tv);
...	...	@@ -4134,7 +4429,7 @@ fn resolveInst(self: *Self, inst: Air.Inst.Ref) InnerError!MCValue {
4134	4429
4135	4430	// If the type has no codegen bits, no need to store it.
4136	4431	const inst_ty = self.air.typeOf(inst);
4137		if (!inst_ty.hasRuntimeBits() and !inst_ty.isError())
	4432	if (!inst_ty.hasRuntimeBitsIgnoreComptime() and !inst_ty.isError())
4138	4433	return MCValue{ .none = {} };
4139	4434
4140	4435	const inst_index = @intCast(Air.Inst.Index, ref_int - Air.Inst.Ref.typed_value_map.len);
...	...	@@ -4334,6 +4629,53 @@ fn structFieldPtr(self: *Self, inst: Air.Inst.Index, operand: Air.Inst.Ref, inde
4334	4629	};
4335	4630	}
4336	4631
	4632	fn trunc(
	4633	self: *Self,
	4634	maybe_inst: ?Air.Inst.Index,
	4635	operand: MCValue,
	4636	operand_ty: Type,
	4637	dest_ty: Type,
	4638	) !MCValue {
	4639	const info_a = operand_ty.intInfo(self.target.*);
	4640	const info_b = dest_ty.intInfo(self.target.*);
	4641
	4642	if (info_b.bits <= 64) {
	4643	const operand_reg = switch (operand) {
	4644	.register => \|r\| r,
	4645	else => operand_reg: {
	4646	if (info_a.bits <= 64) {
	4647	const reg = try self.copyToTmpRegister(operand_ty, operand);
	4648	break :operand_reg reg;
	4649	} else {
	4650	return self.fail("TODO load least significant word into register", .{});
	4651	}
	4652	},
	4653	};
	4654	const lock = self.register_manager.lockReg(operand_reg);
	4655	defer if (lock) \|reg\| self.register_manager.unlockReg(reg);
	4656
	4657	const dest_reg = if (maybe_inst) \|inst\| blk: {
	4658	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
	4659
	4660	if (operand == .register and self.reuseOperand(inst, ty_op.operand, 0, operand)) {
	4661	break :blk operand_reg;
	4662	} else {
	4663	const reg = try self.register_manager.allocReg(inst, gp);
	4664	break :blk reg;
	4665	}
	4666	} else blk: {
	4667	const reg = try self.register_manager.allocReg(null, gp);
	4668	break :blk reg;
	4669	};
	4670
	4671	try self.truncRegister(operand_reg, dest_reg, info_b.signedness, info_b.bits);
	4672
	4673	return MCValue{ .register = dest_reg };
	4674	} else {
	4675	return self.fail("TODO: truncate to ints > 64 bits", .{});
	4676	}
	4677	}
	4678
4337	4679	fn truncRegister(
4338	4680	self: *Self,
4339	4681	operand_reg: Register,

test/behavior/align.zig+21

...	...	@@ -18,6 +18,7 @@ test "global variable alignment" {
18	18	test "slicing array of length 1 can not assume runtime index is always zero" {
19	19	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
20	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21	22
22	23	var runtime_index: usize = 1;
23	24	const slice = @as(*align(4) [1]u8, &foo)[runtime_index..];
...	...	@@ -62,6 +63,7 @@ test "alignment of struct with pointer has same alignment as usize" {
62	63	test "alignment and size of structs with 128-bit fields" {
63	64	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
64	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	66	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
65	67
66	68	const A = struct {
67	69	x: u128,
...	...	@@ -217,6 +219,7 @@ fn fnWithAlignedStack() i32 {
217	219
218	220	test "implicitly decreasing slice alignment" {
219	221	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
220	223
221	224	const a: u32 align(4) = 3;
222	225	const b: u32 align(8) = 4;
...	...	@@ -228,6 +231,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
228	231
229	232	test "specifying alignment allows pointer cast" {
230	233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
231	235
232	236	try testBytesAlign(0x33);
233	237	}
...	...	@@ -240,6 +244,7 @@ fn testBytesAlign(b: u8) !void {
240	244	test "@alignCast slices" {
241	245	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
242	246	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243	248
244	249	var array align(4) = [_]u32{ 1, 1 };
245	250	const slice = array[0..];
...	...	@@ -257,6 +262,7 @@ test "return error union with 128-bit integer" {
257	262	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
258	263	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
259	264	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
260	266
261	267	try expect(3 == try give());
262	268	}
...	...	@@ -268,6 +274,7 @@ test "page aligned array on stack" {
268	274	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
269	275	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
270	276	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	277	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
271	278	// https://github.com/ziglang/zig/issues/13679
272	279	if (builtin.zig_backend == .stage2_llvm and
273	280	builtin.cpu.arch == .aarch64 and
...	...	@@ -296,6 +303,7 @@ fn noop4() align(4) void {}
296	303	test "function alignment" {
297	304	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
298	305	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
299	307
300	308	// function alignment is a compile error on wasm32/wasm64
301	309	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -310,6 +318,7 @@ test "function alignment" {
310	318	test "implicitly decreasing fn alignment" {
311	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
312	320	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	321	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313	322
314	323	// function alignment is a compile error on wasm32/wasm64
315	324	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -332,6 +341,7 @@ fn alignedBig() align(16) i32 {
332	341	test "@alignCast functions" {
333	342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
334	343	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
335	345
336	346	// function alignment is a compile error on wasm32/wasm64
337	347	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -352,6 +362,7 @@ fn simple4() align(4) i32 {
352	362	test "function align expression depends on generic parameter" {
353	363	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
354	364	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	365	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
355	366
356	367	// function alignment is a compile error on wasm32/wasm64
357	368	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -373,6 +384,8 @@ test "function align expression depends on generic parameter" {
373	384	}
374	385
375	386	test "function callconv expression depends on generic parameter" {
	387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	388
376	389	const S = struct {
377	390	fn doTheTest() !void {
378	391	try expect(foobar(.C, 1) == 2);
...	...	@@ -388,6 +401,8 @@ test "function callconv expression depends on generic parameter" {
388	401	}
389	402
390	403	test "runtime-known array index has best alignment possible" {
	404	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	405
391	406	// take full advantage of over-alignment
392	407	var array align(4) = [_]u8{ 1, 2, 3, 4 };
393	408	comptime assert(@TypeOf(&array[0]) == *align(4) u8);
...	...	@@ -443,6 +458,7 @@ test "read 128-bit field from default aligned struct in stack memory" {
443	458	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
444	459	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
445	460	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	461	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
446	462
447	463	var default_aligned = DefaultAligned{
448	464	.nevermind = 1,
...	...	@@ -460,6 +476,7 @@ test "read 128-bit field from default aligned struct in global memory" {
460	476	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
461	477	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
462	478	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	479	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
463	480
464	481	try expect(12 == default_aligned_global.badguy);
465	482	}
...	...	@@ -468,6 +485,7 @@ test "struct field explicit alignment" {
468	485	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
469	486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
470	487	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
471	489
472	490	const S = struct {
473	491	const Node = struct {
...	...	@@ -511,6 +529,7 @@ test "align(N) on functions" {
511	529	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
512	530	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
513	531	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	532	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
514	533
515	534	// function alignment is a compile error on wasm32/wasm64
516	535	if (native_arch == .wasm32 or native_arch == .wasm64) return error.SkipZigTest;
...	...	@@ -527,6 +546,7 @@ test "comptime alloc alignment" {
527	546	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
528	547	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
529	548	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	549	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
530	550
531	551	comptime var bytes1 = [_]u8{0};
532	552	_ = bytes1;
...	...	@@ -538,6 +558,7 @@ test "comptime alloc alignment" {
538	558
539	559	test "@alignCast null" {
540	560	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	561	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
541	562
542	563	var ptr: ?*anyopaque = null;
543	564	const aligned: ?anyopaque = @alignCast(@alignOf(?anyopaque), ptr);

test/behavior/array.zig+27

...	...	@@ -20,6 +20,7 @@ test "array to slice" {
20	20	test "arrays" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	24
24	25	var array: [5]u32 = undefined;
25	26
...	...	@@ -46,6 +47,7 @@ fn getArrayLen(a: []const u32) usize {
46	47
47	48	test "array init with mult" {
48	49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49	51
50	52	const a = 'a';
51	53	var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
...	...	@@ -85,6 +87,7 @@ const some_array = [_]u8{ 0, 1, 2, 3 };
85	87	test "array literal with specified size" {
86	88	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
87	89	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	90	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
88	91
89	92	var array = [2]u8{ 1, 2 };
90	93	try expect(array[0] == 1);
...	...	@@ -92,6 +95,8 @@ test "array literal with specified size" {
92	95	}
93	96
94	97	test "array len field" {
	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	99
95	100	var arr = [4]u8{ 0, 0, 0, 0 };
96	101	var ptr = &arr;
97	102	try expect(arr.len == 4);
...	...	@@ -103,6 +108,7 @@ test "array len field" {
103	108
104	109	test "array with sentinels" {
105	110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	112
107	113	const S = struct {
108	114	fn doTheTest(is_ct: bool) !void {
...	...	@@ -139,6 +145,7 @@ test "void arrays" {
139	145	test "nested arrays of strings" {
140	146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
141	147	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	148	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
142	149
143	150	const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" };
144	151	for (array_of_strings) \|s, i\| {
...	...	@@ -166,6 +173,7 @@ test "nested arrays of integers" {
166	173
167	174	test "implicit comptime in array type size" {
168	175	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	176	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
169	177
170	178	var arr: [plusOne(10)]bool = undefined;
171	179	try expect(arr.len == 11);
...	...	@@ -177,6 +185,7 @@ fn plusOne(x: u32) u32 {
177	185
178	186	test "single-item pointer to array indexing and slicing" {
179	187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	188	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180	189
181	190	try testSingleItemPtrArrayIndexSlice();
182	191	comptime try testSingleItemPtrArrayIndexSlice();
...	...	@@ -201,6 +210,8 @@ fn doSomeMangling(array: *[4]u8) void {
201	210	}
202	211
203	212	test "implicit cast zero sized array ptr to slice" {
	213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	214
204	215	{
205	216	var b = "".*;
206	217	const c: []const u8 = &b;
...	...	@@ -216,6 +227,7 @@ test "implicit cast zero sized array ptr to slice" {
216	227	test "anonymous list literal syntax" {
217	228	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
218	229	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	230	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
219	231
220	232	const S = struct {
221	233	fn doTheTest() !void {
...	...	@@ -235,6 +247,7 @@ const Sub = struct { b: u8 };
235	247	const Str = struct { a: []Sub };
236	248	test "set global var array via slice embedded in struct" {
237	249	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	250	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238	251
239	252	var s = Str{ .a = s_array[0..] };
240	253
...	...	@@ -250,6 +263,7 @@ test "set global var array via slice embedded in struct" {
250	263	test "read/write through global variable array of struct fields initialized via array mult" {
251	264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
252	265	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
253	267
254	268	const S = struct {
255	269	fn doTheTest() !void {
...	...	@@ -269,6 +283,7 @@ test "read/write through global variable array of struct fields initialized via
269	283
270	284	test "implicit cast single-item pointer" {
271	285	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	286	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
272	287
273	288	try testImplicitCastSingleItemPtr();
274	289	comptime try testImplicitCastSingleItemPtr();
...	...	@@ -287,6 +302,7 @@ fn testArrayByValAtComptime(b: [2]u8) u8 {
287	302
288	303	test "comptime evaluating function that takes array by value" {
289	304	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290	306
291	307	const arr = [_]u8{ 1, 2 };
292	308	const x = comptime testArrayByValAtComptime(arr);
...	...	@@ -297,6 +313,7 @@ test "comptime evaluating function that takes array by value" {
297	313
298	314	test "runtime initialize array elem and then implicit cast to slice" {
299	315	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	316	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
300	317
301	318	var two: i32 = 2;
302	319	const x: []const i32 = &[_]i32{two};
...	...	@@ -305,6 +322,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
305	322
306	323	test "array literal as argument to function" {
307	324	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	325	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
308	326
309	327	const S = struct {
310	328	fn entry(two: i32) !void {
...	...	@@ -332,6 +350,7 @@ test "array literal as argument to function" {
332	350	test "double nested array to const slice cast in array literal" {
333	351	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
334	352	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	353	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
335	354
336	355	const S = struct {
337	356	fn entry(two: i32) !void {
...	...	@@ -392,6 +411,7 @@ test "double nested array to const slice cast in array literal" {
392	411	test "anonymous literal in array" {
393	412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
394	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
395	415
396	416	const S = struct {
397	417	const Foo = struct {
...	...	@@ -415,6 +435,7 @@ test "anonymous literal in array" {
415	435
416	436	test "access the null element of a null terminated array" {
417	437	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	438	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
418	439
419	440	const S = struct {
420	441	fn doTheTest() !void {
...	...	@@ -431,6 +452,7 @@ test "access the null element of a null terminated array" {
431	452	test "type deduction for array subscript expression" {
432	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
433	454	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	455	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
434	456
435	457	const S = struct {
436	458	fn doTheTest() !void {
...	...	@@ -448,6 +470,7 @@ test "type deduction for array subscript expression" {
448	470	test "sentinel element count towards the ABI size calculation" {
449	471	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
450	472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
451	474
452	475	const S = struct {
453	476	fn doTheTest() !void {
...	...	@@ -470,6 +493,7 @@ test "sentinel element count towards the ABI size calculation" {
470	493
471	494	test "zero-sized array with recursive type definition" {
472	495	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	496	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
473	497
474	498	const U = struct {
475	499	fn foo(comptime T: type, comptime n: usize) type {
...	...	@@ -524,6 +548,7 @@ test "type coercion of pointer to anon struct literal to pointer to array" {
524	548	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
525	549	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
526	550	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	551	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
527	552
528	553	const S = struct {
529	554	const U = union {
...	...	@@ -561,6 +586,7 @@ test "array with comptime-only element type" {
561	586	test "tuple to array handles sentinel" {
562	587	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
563	588	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	589	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
564	590
565	591	const S = struct {
566	592	const a = .{ 1, 2, 3 };
...	...	@@ -573,6 +599,7 @@ test "array init of container level array variable" {
573	599	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
574	600	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
575	601	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	602	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
576	603
577	604	const S = struct {
578	605	var pair: [2]usize = .{ 1, 2 };

test/behavior/asm.zig+5

...	...	@@ -22,6 +22,7 @@ test "module level assembly" {
22	22	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25	26
26	27	if (is_x86_64_linux) {
27	28	try expect(this_is_my_alias() == 1234);
...	...	@@ -33,6 +34,7 @@ test "output constraint modifiers" {
33	34	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
34	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
35	36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	37	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36	38
37	39	// This is only testing compilation.
38	40	var a: u32 = 3;
...	...	@@ -53,6 +55,7 @@ test "alternative constraints" {
53	55	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
54	56	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
55	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	59
57	60	// Make sure we allow commas as a separator for alternative constraints.
58	61	var a: u32 = 3;
...	...	@@ -68,6 +71,7 @@ test "sized integer/float in asm input" {
68	71	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
69	72	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
70	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	74	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	75
72	76	asm volatile (""
73	77	:
...	...	@@ -116,6 +120,7 @@ test "struct/array/union types as input values" {
116	120	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
117	121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
118	122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
119	124
120	125	asm volatile (""
121	126	:

test/behavior/basic.zig+36

...	...	@@ -45,6 +45,8 @@ const g1: i32 = 1233 + 1;
45	45	var g2: i32 = 0;
46	46
47	47	test "global variables" {
	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	49
48	50	try expect(g2 == 0);
49	51	g2 = g1;
50	52	try expect(g2 == 1234);
...	...	@@ -112,18 +114,21 @@ fn first4KeysOfHomeRow() []const u8 {
112	114
113	115	test "return string from function" {
114	116	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
115	118
116	119	try expect(mem.eql(u8, first4KeysOfHomeRow(), "aoeu"));
117	120	}
118	121
119	122	test "hex escape" {
120	123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	124	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
121	125
122	126	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
123	127	}
124	128
125	129	test "multiline string" {
126	130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	131	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127	132
128	133	const s1 =
129	134	\\one
...	...	@@ -136,6 +141,7 @@ test "multiline string" {
136	141
137	142	test "multiline string comments at start" {
138	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	144	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
139	145
140	146	const s1 =
141	147	//\\one
...	...	@@ -148,6 +154,7 @@ test "multiline string comments at start" {
148	154
149	155	test "multiline string comments at end" {
150	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
151	158
152	159	const s1 =
153	160	\\one
...	...	@@ -160,6 +167,7 @@ test "multiline string comments at end" {
160	167
161	168	test "multiline string comments in middle" {
162	169	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	170	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	171
164	172	const s1 =
165	173	\\one
...	...	@@ -172,6 +180,7 @@ test "multiline string comments in middle" {
172	180
173	181	test "multiline string comments at multiple places" {
174	182	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
175	184
176	185	const s1 =
177	186	\\one
...	...	@@ -190,6 +199,7 @@ test "string concatenation" {
190	199
191	200	test "array mult operator" {
192	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
193	203
194	204	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
195	205	}
...	...	@@ -199,6 +209,7 @@ const OpaqueB = opaque {};
199	209
200	210	test "opaque types" {
201	211	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	212	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
202	213
203	214	try expect(OpaqueA != OpaqueB);
204	215
...	...	@@ -216,6 +227,7 @@ test "compile time global reinterpret" {
216	227
217	228	test "cast undefined" {
218	229	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	230	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
219	231
220	232	const array: [100]u8 = undefined;
221	233	const slice = @as([]const u8, &array);
...	...	@@ -228,6 +240,7 @@ fn testCastUndefined(x: []const u8) void {
228	240	test "implicit cast after unreachable" {
229	241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
230	242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
231	244
232	245	try expect(outer() == 1234);
233	246	}
...	...	@@ -285,6 +298,7 @@ fn fB() []const u8 {
285	298
286	299	test "call function pointer in struct" {
287	300	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	301	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
288	302
289	303	try expect(mem.eql(u8, f3(true), "a"));
290	304	try expect(mem.eql(u8, f3(false), "b"));
...	...	@@ -326,6 +340,7 @@ test "call result of if else expression" {
326	340	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
327	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
328	342	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
329	344
330	345	try expect(mem.eql(u8, f2(true), "a"));
331	346	try expect(mem.eql(u8, f2(false), "b"));
...	...	@@ -337,6 +352,7 @@ fn f2(x: bool) []const u8 {
337	352	test "memcpy and memset intrinsics" {
338	353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
339	354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
340	356
341	357	try testMemcpyMemset();
342	358	// TODO add comptime test coverage
...	...	@@ -367,6 +383,7 @@ fn hereIsAnOpaqueType(ptr: OpaqueA) OpaqueA {
367	383	test "take address of parameter" {
368	384	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
369	385	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	386	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
370	387
371	388	try testTakeAddressOfParameter(12.34);
372	389	}
...	...	@@ -443,6 +460,7 @@ fn testArray2DConstDoublePtr(ptr: *const f32) !void {
443	460
444	461	test "double implicit cast in same expression" {
445	462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	463	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
446	464
447	465	var x = @as(i32, @as(u16, nine()));
448	466	try expect(x == 9);
...	...	@@ -453,6 +471,7 @@ fn nine() u8 {
453	471
454	472	test "struct inside function" {
455	473	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	474	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
456	475
457	476	try testStructInFn();
458	477	comptime try testStructInFn();
...	...	@@ -474,6 +493,7 @@ fn testStructInFn() !void {
474	493
475	494	test "fn call returning scalar optional in equality expression" {
476	495	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	496	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
477	497	try expect(getNull() == null);
478	498	}
479	499
...	...	@@ -484,6 +504,7 @@ fn getNull() ?*i32 {
484	504	test "global variable assignment with optional unwrapping with var initialized to undefined" {
485	505	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
486	506	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	507	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
487	508
488	509	const S = struct {
489	510	var data: i32 = 1234;
...	...	@@ -501,6 +522,7 @@ var global_foo: *i32 = undefined;
501	522
502	523	test "peer result location with typed parent, runtime condition, comptime prongs" {
503	524	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	525	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
504	526
505	527	const S = struct {
506	528	fn doTheTest(arg: i32) i32 {
...	...	@@ -592,6 +614,8 @@ test "self reference through fn ptr field" {
592	614	}
593	615
594	616	test "global variable initialized to global variable array element" {
	617	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	618
595	619	try expect(global_ptr == &gdt[0]);
596	620	}
597	621	const GDTEntry = struct {
...	...	@@ -605,6 +629,7 @@ var global_ptr = &gdt[0];
605	629
606	630	test "global constant is loaded with a runtime-known index" {
607	631	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	632	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
608	633
609	634	const S = struct {
610	635	fn doTheTest() !void {
...	...	@@ -636,6 +661,7 @@ test "string escapes" {
636	661	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
637	662	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
638	663	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	664	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
639	665
640	666	try expectEqualStrings("\"", "\x22");
641	667	try expectEqualStrings("\'", "\x27");
...	...	@@ -667,6 +693,7 @@ test "string concatenation" {
667	693	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
668	694	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
669	695	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	696	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
670	697
671	698	const a = "OK" ++ " IT " ++ "WORKED";
672	699	const b = "OK IT WORKED";
...	...	@@ -694,6 +721,7 @@ test "comptime manyptr concatenation" {
694	721	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
695	722	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
696	723	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	724	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
697	725
698	726	const s = "epic";
699	727	const actual = manyptrConcat(s);
...	...	@@ -714,6 +742,7 @@ test "comptime manyptr concatenation" {
714	742	test "result location is optional inside error union" {
715	743	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
716	744	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	745	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
717	746
718	747	const x = maybe(true) catch unreachable;
719	748	try expect(x.? == 42);
...	...	@@ -728,6 +757,7 @@ fn maybe(x: bool) anyerror!?u32 {
728	757
729	758	test "auto created variables have correct alignment" {
730	759	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	760	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
731	761
732	762	const S = struct {
733	763	fn foo(str: [*]const u8) u32 {
...	...	@@ -746,6 +776,7 @@ test "extern variable with non-pointer opaque type" {
746	776	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
747	777	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
748	778	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	779	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
749	780
750	781	@export(var_to_export, .{ .name = "opaque_extern_var" });
751	782	try expect(@ptrCast(align(1) u32, &opaque_extern_var). == 42);
...	...	@@ -787,6 +818,7 @@ test "if expression type coercion" {
787	818	test "discarding the result of various expressions" {
788	819	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
789	820	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	821	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
790	822
791	823	const S = struct {
792	824	fn foo() !u32 {
...	...	@@ -826,6 +858,7 @@ test "labeled block implicitly ends in a break" {
826	858
827	859	test "catch in block has correct result location" {
828	860	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	861	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
829	862
830	863	const S = struct {
831	864	fn open() error{A}!@This() {
...	...	@@ -856,6 +889,7 @@ test "labeled block with runtime branch forwards its result location type to bre
856	889
857	890	test "try in labeled block doesn't cast to wrong type" {
858	891	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	892	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
859	893
860	894	const S = struct {
861	895	a: u32,
...	...	@@ -883,6 +917,7 @@ test "weird array and tuple initializations" {
883	917	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
884	918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
885	919	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	920	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
886	921
887	922	const E = enum { a, b };
888	923	const S = struct { e: E };
...	...	@@ -1000,6 +1035,7 @@ comptime {
1000	1035
1001	1036	test "switch inside @as gets correct type" {
1002	1037	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1038	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1003	1039
1004	1040	var a: u32 = 0;
1005	1041	var b: [2]u32 = undefined;

test/behavior/bit_shifting.zig+2

...	...	@@ -64,6 +64,8 @@ test "sharded table" {
64	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
65	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66	66	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	68
67	69	// realistic 16-way sharding
68	70	try testShardedTable(u32, 4, 8);
69	71

test/behavior/bitcast.zig+10

...	...	@@ -21,6 +21,7 @@ test "@bitCast iX -> uX (8, 16, 128)" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24	25
25	26	const bit_values = [_]usize{ 8, 16, 128 };
26	27
...	...	@@ -36,6 +37,7 @@ test "@bitCast iX -> uX exotic integers" {
36	37	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
37	38	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
38	39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
39	41
40	42	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
41	43
...	...	@@ -82,6 +84,7 @@ test "bitcast uX to bytes" {
82	84	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
83	85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
84	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	87	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
85	88
86	89	const bit_values = [_]usize{ 1, 48, 27, 512, 493, 293, 125, 204, 112 };
87	90	inline for (bit_values) \|bits\| {
...	...	@@ -158,6 +161,7 @@ test "@bitCast packed structs at runtime and comptime" {
158	161	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
159	162	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
160	163	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
161	165
162	166	const Full = packed struct {
163	167	number: u16,
...	...	@@ -182,6 +186,7 @@ test "@bitCast packed structs at runtime and comptime" {
182	186
183	187	test "@bitCast extern structs at runtime and comptime" {
184	188	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
185	190
186	191	const Full = extern struct {
187	192	number: u16,
...	...	@@ -214,6 +219,7 @@ test "bitcast packed struct to integer and back" {
214	219	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
215	220	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
216	221	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	222	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217	223
218	224	const LevelUpMove = packed struct {
219	225	move_id: u9,
...	...	@@ -235,6 +241,7 @@ test "bitcast packed struct to integer and back" {
235	241	test "implicit cast to error union by returning" {
236	242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
237	243	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	244	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
238	245
239	246	const S = struct {
240	247	fn entry() !void {
...	...	@@ -289,6 +296,7 @@ test "@bitCast packed struct of floats" {
289	296	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
290	297	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
291	298	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
292	300
293	301	const Foo = packed struct {
294	302	a: f16 = 0,
...	...	@@ -324,6 +332,7 @@ test "comptime @bitCast packed struct to int and back" {
324	332	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
325	333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
326	334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
327	336
328	337	const S = packed struct {
329	338	void: void = {},
...	...	@@ -362,6 +371,7 @@ test "comptime bitcast with fields following f80" {
362	371	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
363	372	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
364	373	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	374	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
365	375
366	376	const FloatT = extern struct { f: f80, x: u128 align(16) };
367	377	const x: FloatT = .{ .f = 0.5, .x = 123 };

test/behavior/bitreverse.zig+4

...	...	@@ -14,6 +14,7 @@ test "@bitReverse" {
14	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18
18	19	comptime try testBitReverse();
19	20	try testBitReverse();
...	...	@@ -99,6 +100,7 @@ test "bitReverse vectors u8" {
99	100	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
100	101	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
101	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	103	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
102	104
103	105	comptime try vector8();
104	106	try vector8();
...	...	@@ -117,6 +119,7 @@ test "bitReverse vectors u16" {
117	119	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
118	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
119	121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120	123
121	124	comptime try vector16();
122	125	try vector16();
...	...	@@ -135,6 +138,7 @@ test "bitReverse vectors u24" {
135	138	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
136	139	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
137	140	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	141	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
138	142
139	143	comptime try vector24();
140	144	try vector24();

test/behavior/bugs/10147.zig+1

...	...	@@ -7,6 +7,7 @@ test "test calling @clz on both vector and scalar inputs" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	var x: u32 = 0x1;
12	13	var y: @Vector(4, u32) = [_]u32{ 0x1, 0x1, 0x1, 0x1 };

test/behavior/bugs/1076.zig+1

...	...	@@ -6,6 +6,7 @@ const expect = std.testing.expect;
6	6	test "comptime code should not modify constant data" {
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	try testCastPtrOfArrayToSliceAndPtr();
11	12	comptime try testCastPtrOfArrayToSliceAndPtr();

test/behavior/bugs/10970.zig+1

...	...	@@ -7,6 +7,7 @@ test "breaking from a loop in an if statement" {
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	var cond = true;
12	13	const opt = while (cond) {

test/behavior/bugs/11046.zig+1

...	...	@@ -13,6 +13,7 @@ test "fixed" {
13	13	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	17
17	18	bar() catch \|err\| switch (err) {
18	19	error.Foo => {}, // error: expected (inferred error set of bar), found error{Foo}

test/behavior/bugs/11139.zig+1

...	...	@@ -5,6 +5,7 @@ const expect = std.testing.expect;
5	5	test "store array of array of structs at comptime" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	try expect(storeArrayOfArrayOfStructs() == 15);
10	11	comptime try expect(storeArrayOfArrayOfStructs() == 15);

test/behavior/bugs/11165.zig+4

...	...	@@ -1,6 +1,8 @@
1	1	const builtin = @import("builtin");
2	2
3	3	test "bytes" {
	4	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	5
4	6	const S = struct {
5	7	a: u32,
6	8	c: [5]u8,
...	...	@@ -20,6 +22,8 @@ test "bytes" {
20	22	}
21	23
22	24	test "aggregate" {
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26
23	27	const S = struct {
24	28	a: u32,
25	29	c: [5]u8,

test/behavior/bugs/11181.zig+2

...	...	@@ -12,6 +12,8 @@ test "const inferred array of slices" {
12	12	}
13	13
14	14	test "var inferred array of slices" {
	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	16
15	17	const T = struct { v: bool };
16	18
17	19	var decls = [_][]const T{

test/behavior/bugs/11816.zig+1

...	...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");
3	3
4	4	test {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6	7
7	8	var x: u32 = 3;
8	9	const val: usize = while (true) switch (x) {

test/behavior/bugs/12551.zig+1

...	...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");
3	3
4	4	test {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	6	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
6	7
7	8	try std.testing.expect(for ([1]u8{0}) \|x\| {
8	9	if (x == 0) break true;

test/behavior/bugs/12680.zig+1

...	...	@@ -10,6 +10,7 @@ test "export a function twice" {
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	14
14	15	// If it exports the function correctly, `test_func` and `testFunc` will points to the same address.
15	16	try expectEqual(test_func(), other_file.testFunc());

test/behavior/bugs/1277.zig+1

...	...	@@ -15,6 +15,7 @@ test "don't emit an LLVM global for a const function when it's in an optional in
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	19
19	20	try std.testing.expect(s.f.?() == 1234);
20	21	}

test/behavior/bugs/12776.zig+1

...	...	@@ -32,6 +32,7 @@ test {
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
33	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	34	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest;
35	36
36	37	var ram = try RAM.new();
37	38	var cpu = try CPU.new(&ram);

test/behavior/bugs/12801-2.zig+1

...	...	@@ -17,6 +17,7 @@ test {
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20	21
21	22	const a: Auto = .{ .offset = 16, .capacity = Auto.capacity };
22	23	try std.testing.expect(a.capacity() == 32);

test/behavior/bugs/12890.zig+1

...	...	@@ -11,6 +11,7 @@ fn a(b: []u3, c: u3) void {
11	11	test {
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14	15
15	16	var arr: [8]u3 = undefined;
16	17	a(&arr, 5);

test/behavior/bugs/12972.zig+1

...	...	@@ -5,6 +5,7 @@ pub fn f(_: [:null]const ?u8) void {}
5	5	test {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	const c: u8 = 42;
10	11	f(&[_:null]?u8{c});

test/behavior/bugs/13063.zig+5

...	...	@@ -1,8 +1,11 @@
1	1	const std = @import("std");
	2	const builtin = @import("builtin");
2	3	const expect = std.testing.expect;
3	4
4	5	var pos = [2]f32{ 0.0, 0.0 };
5	6	test "store to global array" {
	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	8
6	9	try expect(pos[1] == 0.0);
7	10	pos = [2]f32{ 0.0, 1.0 };
8	11	try expect(pos[1] == 1.0);
...	...	@@ -10,6 +13,8 @@ test "store to global array" {
10	13
11	14	var vpos = @Vector(2, f32){ 0.0, 0.0 };
12	15	test "store to global vector" {
	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	17
13	18	try expect(vpos[1] == 0.0);
14	19	vpos = @Vector(2, f32){ 0.0, 1.0 };
15	20	try expect(vpos[1] == 1.0);

test/behavior/bugs/13064.zig+1

...	...	@@ -5,6 +5,7 @@ const expect = std.testing.expect;
5	5	test {
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	var x: [10][10]u32 = undefined;
10	11

test/behavior/bugs/13065.zig+1

...	...	@@ -10,6 +10,7 @@ const U = union(enum) {
10	10	test {
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	14
14	15	var x = U{ .array = undefined };
15	16

test/behavior/bugs/13068.zig+1

...	...	@@ -9,6 +9,7 @@ test {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	list.items.len = 0;
14	15	}

test/behavior/bugs/13069.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	var opt_x: ?[3]f32 = [_]f32{0.0} ** 3;
11	12

test/behavior/bugs/13128.zig+1

...	...	@@ -16,6 +16,7 @@ test "runtime union init, most-aligned field != largest" {
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	20
20	21	var x: u8 = 1;
21	22	try foo(.{ .x = x });

test/behavior/bugs/13159.zig+2

...	...	@@ -1,3 +1,4 @@
	1	const builtin = @import("builtin");
1	2	const std = @import("std");
2	3	const expect = std.testing.expect;
3	4
...	...	@@ -9,6 +10,7 @@ const Bar = packed struct {
9	10	};
10	11
11	12	test {
	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	14	var foo = Bar.Baz.fizz;
13	15	try expect(foo == .fizz);
14	16	}

test/behavior/bugs/13164.zig+1

...	...	@@ -11,6 +11,7 @@ test {
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14	15
15	16	var x: u32 = 42;
16	17	try setLimits(x, null);

test/behavior/bugs/13285.zig+4

...	...	@@ -1,8 +1,12 @@
	1	const builtin = @import("builtin");
	2
1	3	const Crasher = struct {
2	4	lets_crash: u64 = 0,
3	5	};
4	6
5	7	test {
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9
6	10	var a: Crasher = undefined;
7	11	var crasher_ptr = &a;
8	12	var crasher_local = crasher_ptr.*;

test/behavior/bugs/13664.zig+1

...	...	@@ -17,6 +17,7 @@ test {
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
19	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20	21
21	22	const timestamp: i64 = value();
22	23	const id = ID{ .fields = Fields{

test/behavior/bugs/13785.zig+1

...	...	@@ -6,6 +6,7 @@ test {
6	6	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	var a: u8 = 0;
11	12	try std.io.null_writer.print("\n{} {}\n", .{ a, S{} });

test/behavior/bugs/1381.zig+1

...	...	@@ -16,6 +16,7 @@ test "union that needs padding bytes inside an array" {
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
18	18	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	20
20	21	var as = [_]A{
21	22	A{ .B = B{ .D = 1 } },

test/behavior/bugs/1442.zig+1

...	...	@@ -10,6 +10,7 @@ test "const error union field alignment" {
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12	12	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	14	var union_or_err: anyerror!Union = Union{ .Color = 1234 };
14	15	try std.testing.expect((union_or_err catch unreachable).Color == 1234);
15	16	}

test/behavior/bugs/1486.zig+1

...	...	@@ -7,6 +7,7 @@ var global: usize = 123;
7	7
8	8	test "constant pointer to global variable causes runtime load" {
9	9	if (builtin.zig_backend == .stage2_aarch64 and builtin.os.tag == .macos) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11	global = 1234;
11	12	try expect(&global == ptr);
12	13	try expect(ptr.* == 1234);

test/behavior/bugs/1607.zig+1

...	...	@@ -14,6 +14,7 @@ test "slices pointing at the same address as global array." {
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18	try checkAddress(&a);
18	19	comptime try checkAddress(&a);
19	20	}

test/behavior/bugs/1735.zig+1

...	...	@@ -43,6 +43,7 @@ const a = struct {
43	43
44	44	test "initialization" {
45	45	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	46	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46	47	var t = a.init();
47	48	try std.testing.expect(t.foo.len == 0);
48	49	}

test/behavior/bugs/1851.zig+1

...	...	@@ -7,6 +7,7 @@ test "allocation and looping over 3-byte integer" {
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .macos) {
12	13	return error.SkipZigTest; // TODO

test/behavior/bugs/2006.zig+2

...	...	@@ -6,6 +6,8 @@ const S = struct {
6	6	p: *S,
7	7	};
8	8	test "bug 2006" {
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10
9	11	var a: S = undefined;
10	12	a = S{ .p = undefined };
11	13	try expect(@sizeOf(S) != 0);

test/behavior/bugs/2114.zig+1

...	...	@@ -12,6 +12,7 @@ test "fixed" {
12	12	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
15	16
16	17	try testCtz();
17	18	comptime try testCtz();

test/behavior/bugs/2578.zig+1

...	...	@@ -15,6 +15,7 @@ test "fixed" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	19
19	20	bar(t);
20	21	}

test/behavior/bugs/2692.zig+1

...	...	@@ -6,6 +6,7 @@ fn foo(a: []u8) void {
6	6
7	7	test "address of 0 length array" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	var pt: [0]u8 = undefined;
11	12	foo(&pt);

test/behavior/bugs/2889.zig+1

...	...	@@ -29,6 +29,7 @@ fn parseNote() ?i32 {
29	29	test "fixed" {
30	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	33
33	34	const result = parseNote();
34	35	try std.testing.expect(result.? == 9);

test/behavior/bugs/3007.zig+1

...	...	@@ -22,6 +22,7 @@ test "fixed" {
22	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25	26
26	27	default_foo = get_foo() catch null; // This Line
27	28	try std.testing.expect(!default_foo.?.free);

test/behavior/bugs/3046.zig+1

...	...	@@ -15,6 +15,7 @@ var some_struct: SomeStruct = undefined;
15	15	test "fixed" {
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
17	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	19
19	20	some_struct = SomeStruct{
20	21	.field = couldFail() catch @as(i32, 0),

test/behavior/bugs/3112.zig+1

...	...	@@ -14,6 +14,7 @@ fn prev(p: ?State) void {
14	14	test "zig test crash" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18	var global: State = undefined;
18	19	global.enter = prev;
19	20	global.enter(null);

test/behavior/bugs/3586.zig+2

...	...	@@ -7,6 +7,8 @@ const Container = struct {
7	7	};
8	8
9	9	test "fixed" {
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	11
10	12	var ctr = Container{
11	13	.params = NoteParams{},
12	14	};

test/behavior/bugs/3742.zig+1

...	...	@@ -38,5 +38,6 @@ test "fixed" {
38	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
39	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
40	40	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	42	ArgSerializer.serializeCommand(GET.init("banana"));
42	43	}

test/behavior/bugs/3779.zig+5

...	...	@@ -7,6 +7,7 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
7	7
8	8	test "@tagName() returns a string literal" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
12	13	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
...	...	@@ -19,6 +20,7 @@ const ptr_error_name: [*:0]const u8 = error_name;
19	20
20	21	test "@errorName() returns a string literal" {
21	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
22	24
23	25	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
24	26	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
...	...	@@ -31,6 +33,7 @@ const ptr_type_name: [*:0]const u8 = type_name;
31	33
32	34	test "@typeName() returns a string literal" {
33	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
34	37
35	38	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
36	39	try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
...	...	@@ -43,6 +46,7 @@ const expected_contents = "hello zig\n";
43	46
44	47	test "@embedFile() returns a string literal" {
45	48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	49	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46	50
47	51	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
48	52	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
...	...	@@ -56,6 +60,7 @@ fn testFnForSrc() std.builtin.SourceLocation {
56	60
57	61	test "@src() returns a struct containing 0-terminated string slices" {
58	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	63	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59	64
60	65	const src = testFnForSrc();
61	66	try std.testing.expect([:0]const u8 == @TypeOf(src.file));

test/behavior/bugs/421.zig+1

...	...	@@ -5,6 +5,7 @@ test "bitCast to array" {
5	5	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	comptime try testBitCastArray();
10	11	try testBitCastArray();

test/behavior/bugs/4328.zig+1

...	...	@@ -53,6 +53,7 @@ test "Peer resolution of extern function calls in @TypeOf" {
53	53
54	54	test "Extern function calls, dereferences and field access in @TypeOf" {
55	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	57
57	58	const Test = struct {
58	59	fn test_fn_1(a: c_long) @TypeOf(c_fopen("test", "r").*) {

test/behavior/bugs/4560.zig+2

...	...	@@ -2,6 +2,8 @@ const std = @import("std");
2	2	const builtin = @import("builtin");
3	3
4	4	test "fixed" {
	5	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	6
5	7	var s: S = .{
6	8	.a = 1,
7	9	.b = .{

test/behavior/bugs/4954.zig+1

...	...	@@ -7,6 +7,7 @@ fn f(buf: []u8) void {
7	7	test "crash" {
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	var buf: [4096]u8 = undefined;
12	13	f(&buf);

test/behavior/bugs/529.zig+1

...	...	@@ -15,6 +15,7 @@ test "issue 529 fixed" {
15	15	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	19
19	20	@import("529_other_file.zig").issue529(null);
20	21	issue529(null);

test/behavior/bugs/5398.zig+1

...	...	@@ -22,6 +22,7 @@ test "assignment of field with padding" {
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
23	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
24	24	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25	26
26	27	renderable = Renderable{
27	28	.mesh = Mesh{ .id = 0 },

test/behavior/bugs/5474.zig+4

...	...	@@ -49,11 +49,15 @@ fn constant() !void {
49	49	}
50	50
51	51	test "pointer-to-array constness for zero-size elements, var" {
	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	53
52	54	try mutable();
53	55	comptime try mutable();
54	56	}
55	57
56	58	test "pointer-to-array constness for zero-size elements, const" {
	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	60
57	61	try constant();
58	62	comptime try constant();
59	63	}

test/behavior/bugs/5487.zig+1

...	...	@@ -13,5 +13,6 @@ test "crash" {
13	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	17	_ = io.multiWriter(.{writer()});
17	18	}

test/behavior/bugs/624.zig+1

...	...	@@ -22,6 +22,7 @@ fn MemoryPool(comptime T: type) type {
22	22	test "foo" {
23	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
24	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25	26
26	27	var allocator = ContextAllocator{ .n = 10 };
27	28	try expect(allocator.n == 10);

test/behavior/bugs/656.zig+1

...	...	@@ -14,6 +14,7 @@ test "optional if after an if in a switch prong of a switch with 2 prongs in an
14	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18	try foo(false, true);
18	19	}
19	20

test/behavior/bugs/6781.zig+1

...	...	@@ -67,6 +67,7 @@ test "fixed" {
67	67	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
68	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
69	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
70	71
71	72	var buffer align(@alignOf(JournalHeader)) = [_]u8{0} ** 65536;
72	73	var entry = std.mem.bytesAsValue(JournalHeader, buffer[0..@sizeOf(JournalHeader)]);

test/behavior/bugs/718.zig+1

...	...	@@ -13,6 +13,7 @@ test "zero keys with @memset" {
13	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
14	14	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
15	15	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	17
17	18	@memset(@ptrCast([*]u8, &keys), 0, @sizeOf(@TypeOf(keys)));
18	19	try expect(!keys.up);

test/behavior/bugs/726.zig+2

...	...	@@ -5,6 +5,7 @@ test "@ptrCast from const to nullable" {
5	5	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	const c: u8 = 4;
10	11	var x: ?const u8 = @ptrCast(?const u8, &c);
...	...	@@ -15,6 +16,7 @@ test "@ptrCast from var in empty struct to nullable" {
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	18	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	20
19	21	const container = struct {
20	22	var c: u8 = 4;

test/behavior/bugs/920.zig+1

...	...	@@ -61,6 +61,7 @@ test "bug 920 fixed" {
61	61	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
62	62	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
63	63	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	64	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64	65
65	66	const NormalDist1 = blk: {
66	67	break :blk ZigTableGen(true, norm_r, norm_v, norm_f, norm_f_inv, norm_zero_case);

test/behavior/byteswap.zig+3

...	...	@@ -66,6 +66,7 @@ test "@byteSwap vectors u8" {
66	66	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
67	67	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
68	68	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69	70
70	71	comptime try vector8();
71	72	try vector8();
...	...	@@ -84,6 +85,7 @@ test "@byteSwap vectors u16" {
84	85	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
85	86	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
86	87	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	88	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
87	89
88	90	comptime try vector16();
89	91	try vector16();
...	...	@@ -102,6 +104,7 @@ test "@byteSwap vectors u24" {
102	104	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
103	105	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
104	106	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	107	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105	108
106	109	comptime try vector24();
107	110	try vector24();

test/behavior/byval_arg_var.zig+1

...	...	@@ -6,6 +6,7 @@ var result: []const u8 = "wrong";
6	6	test "pass string literal byvalue to a generic var param" {
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	start();
11	12	blowUpStack(10);

test/behavior/call.zig+6

...	...	@@ -24,6 +24,7 @@ test "basic invocations" {
24	24	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
26	26	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	27	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27	28
28	29	const foo = struct {
29	30	fn foo() i32 {
...	...	@@ -56,6 +57,7 @@ test "tuple parameters" {
56	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
57	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
58	59	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59	61
60	62	const add = struct {
61	63	fn add(a: i32, b: i32) i32 {
...	...	@@ -87,6 +89,7 @@ test "tuple parameters" {
87	89	test "result location of function call argument through runtime condition and struct init" {
88	90	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	91	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
90	93
91	94	const E = enum { a, b };
92	95	const S = struct {
...	...	@@ -105,6 +108,7 @@ test "result location of function call argument through runtime condition and st
105	108
106	109	test "function call with 40 arguments" {
107	110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
108	112
109	113	const S = struct {
110	114	fn doTheTest(thirty_nine: i32) !void {
...	...	@@ -263,6 +267,7 @@ test "forced tail call" {
263	267	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
264	268	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
265	269	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266	271
267	272	if (builtin.zig_backend == .stage2_llvm) {
268	273	// Only attempt this test on targets we know have tail call support in LLVM.
...	...	@@ -295,6 +300,7 @@ test "inline call preserves tail call" {
295	300	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
296	301	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
297	302	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	303	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
298	304
299	305	if (builtin.zig_backend == .stage2_llvm) {
300	306	// Only attempt this test on targets we know have tail call support in LLVM.

test/behavior/cast.zig+66

...	...	@@ -20,6 +20,7 @@ test "integer literal to pointer cast" {
20	20	test "peer type resolution: ?T and T" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	24
24	25	try expect(peerTypeTAndOptionalT(true, false).? == 0);
25	26	try expect(peerTypeTAndOptionalT(false, false).? == 3);
...	...	@@ -96,6 +97,7 @@ test "@intToFloat" {
96	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
97	98	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
98	99	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
99	101
100	102	const S = struct {
101	103	fn doTheTest() !void {
...	...	@@ -117,6 +119,7 @@ test "@intToFloat(f80)" {
117	119	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
118	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
119	121	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120	123
121	124	const S = struct {
122	125	fn doTheTest(comptime Int: type) !void {
...	...	@@ -151,6 +154,7 @@ test "@floatToInt" {
151	154	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
152	155	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
153	156	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	157	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
154	158
155	159	try testFloatToInts();
156	160	comptime try testFloatToInts();
...	...	@@ -173,6 +177,7 @@ fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void {
173	177	test "implicitly cast indirect pointer to maybe-indirect pointer" {
174	178	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
175	179	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	180	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
176	181
177	182	const S = struct {
178	183	const Self = @This();
...	...	@@ -232,6 +237,7 @@ test "@floatCast comptime_int and comptime_float" {
232	237	test "coerce undefined to optional" {
233	238	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
234	239	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	240	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	241
236	242	try expect(MakeType(void).getNull() == null);
237	243	try expect(MakeType(void).getNonNull() != null);
...	...	@@ -251,6 +257,7 @@ fn MakeType(comptime T: type) type {
251	257
252	258	test "implicit cast from [N]T to [c]T" {
253	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	260	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
254	261
255	262	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
256	263	var y: [*c]u16 = &x;
...	...	@@ -287,6 +294,7 @@ test "@intCast to u0 and use the result" {
287	294	test "peer result null and comptime_int" {
288	295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
289	296	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	297	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
290	298
291	299	const S = struct {
292	300	fn blah(n: i32) ?i32 {
...	...	@@ -311,6 +319,7 @@ test "peer result null and comptime_int" {
311	319	test "const ?[]const T to [c]const [c]const T" {
312	320	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313	321	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	322	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
314	323
315	324	var array = [_]u8{ 'o', 'k' };
316	325	const opt_array_ptr: ?[*]const u8 = &array;
...	...	@@ -322,6 +331,7 @@ test "const ?[]const T to [c]const [c]const T" {
322	331
323	332	test "array coersion to undefined at runtime" {
324	333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	334	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
325	335
326	336	@setRuntimeSafety(true);
327	337
...	...	@@ -351,6 +361,7 @@ fn implicitIntLitToOptional() void {
351	361	test "return u8 coercing into ?u32 return type" {
352	362	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
353	363	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	364	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
354	365
355	366	const S = struct {
356	367	fn doTheTest() !void {
...	...	@@ -371,6 +382,7 @@ test "cast from ?[]T to ??[]T" {
371	382
372	383	test "peer type unsigned int to signed" {
373	384	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	385	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
374	386
375	387	var w: u31 = 5;
376	388	var x: u8 = 7;
...	...	@@ -382,6 +394,7 @@ test "peer type unsigned int to signed" {
382	394
383	395	test "expected [c]const u8, found [:0]const u8" {
384	396	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	397	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
385	398
386	399	var a: [*:0]const u8 = "hello";
387	400	var b: [*c]const u8 = a;
...	...	@@ -394,6 +407,7 @@ test "explicit cast from integer to error type" {
394	407	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
395	408	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
396	409	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
397	411
398	412	try testCastIntToErr(error.ItBroke);
399	413	comptime try testCastIntToErr(error.ItBroke);
...	...	@@ -408,6 +422,7 @@ test "peer resolve array and const slice" {
408	422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
409	423	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
410	424	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	425	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
411	426
412	427	try testPeerResolveArrayConstSlice(true);
413	428	comptime try testPeerResolveArrayConstSlice(true);
...	...	@@ -422,6 +437,7 @@ fn testPeerResolveArrayConstSlice(b: bool) !void {
422	437	test "implicitly cast from T to anyerror!?T" {
423	438	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
424	439	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	440	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
425	441
426	442	try castToOptionalTypeError(1);
427	443	comptime try castToOptionalTypeError(1);
...	...	@@ -446,6 +462,7 @@ fn castToOptionalTypeError(z: i32) !void {
446	462
447	463	test "implicitly cast from [0]T to anyerror![]T" {
448	464	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	465	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
449	466
450	467	try testCastZeroArrayToErrSliceMut();
451	468	comptime try testCastZeroArrayToErrSliceMut();
...	...	@@ -462,6 +479,7 @@ fn gimmeErrOrSlice() anyerror![]u8 {
462	479	test "peer type resolution: [0]u8, []const u8, and anyerror![]u8" {
463	480	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
464	481	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	482	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465	483
466	484	const S = struct {
467	485	fn doTheTest() anyerror!void {
...	...	@@ -492,6 +510,7 @@ fn peerTypeEmptyArrayAndSliceAndError(a: bool, slice: []u8) anyerror![]u8 {
492	510
493	511	test "implicit cast from *const [N]T to []const T" {
494	512	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
495	514
496	515	try testCastConstArrayRefToConstSlice();
497	516	comptime try testCastConstArrayRefToConstSlice();
...	...	@@ -516,6 +535,7 @@ fn testCastConstArrayRefToConstSlice() !void {
516	535
517	536	test "peer type resolution: error and [N]T" {
518	537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
519	539
520	540	try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
521	541	comptime try expect(mem.eql(u8, try testPeerErrorAndArray(0), "OK"));
...	...	@@ -539,6 +559,7 @@ fn testPeerErrorAndArray2(x: u8) anyerror![]const u8 {
539	559
540	560	test "single-item pointer of array to slice to unknown length pointer" {
541	561	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	562	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
542	563
543	564	try testCastPtrOfArrayToSliceAndPtr();
544	565	comptime try testCastPtrOfArrayToSliceAndPtr();
...	...	@@ -568,6 +589,7 @@ fn testCastPtrOfArrayToSliceAndPtr() !void {
568	589	test "cast [1][]const u8 to []const ?[]const u8" {
569	590	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
570	591	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	592	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
571	593
572	594	const window_name = [1][*]const u8{"window name"};
573	595	const x: []const ?[]const u8 = &window_name;
...	...	@@ -580,6 +602,7 @@ test "vector casts" {
580	602	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
581	603	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
582	604	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	605	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
583	606
584	607	const S = struct {
585	608	fn doTheTest() !void {
...	...	@@ -621,6 +644,7 @@ test "@floatCast cast down" {
621	644	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
622	645	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
623	646	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
624	648
625	649	{
626	650	var double: f64 = 0.001534;
...	...	@@ -637,6 +661,7 @@ test "@floatCast cast down" {
637	661	test "peer type resolution: unreachable, error set, unreachable" {
638	662	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
639	663	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	664	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
640	665
641	666	const Error = error{
642	667	FileDescriptorAlreadyPresentInSet,
...	...	@@ -671,6 +696,7 @@ test "peer type resolution: error set supersets" {
671	696	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
672	697	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
673	698	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	699	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
674	700
675	701	const a: error{ One, Two } = undefined;
676	702	const b: error{One} = undefined;
...	...	@@ -700,6 +726,7 @@ test "peer type resolution: disjoint error sets" {
700	726	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
701	727	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
702	728	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	729	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
703	730
704	731	const a: error{ One, Two } = undefined;
705	732	const b: error{Three} = undefined;
...	...	@@ -729,6 +756,7 @@ test "peer type resolution: error union and error set" {
729	756	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
730	757	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
731	758	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	759	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
732	760
733	761	const a: error{Three} = undefined;
734	762	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -762,6 +790,7 @@ test "peer type resolution: error union after non-error" {
762	790	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
763	791	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
764	792	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	793	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
765	794
766	795	const a: u32 = undefined;
767	796	const b: error{ One, Two }!u32 = undefined;
...	...	@@ -795,6 +824,7 @@ test "peer cast *[0]T to E![]const T" {
795	824	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
796	825	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
797	826	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	827	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
798	828
799	829	var buffer: [5]u8 = "abcde".*;
800	830	var buf: anyerror![]const u8 = buffer[0..];
...	...	@@ -809,6 +839,7 @@ test "peer cast *[0]T to []const T" {
809	839	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
810	840	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
811	841	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	842	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
812	843
813	844	var buffer: [5]u8 = "abcde".*;
814	845	var buf: []const u8 = buffer[0..];
...	...	@@ -818,6 +849,8 @@ test "peer cast *[0]T to []const T" {
818	849	}
819	850
820	851	test "peer cast [N]T to []T" {
	852	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	853
821	854	var array = [4:99]i32{ 1, 2, 3, 4 };
822	855	var dest: [*]i32 = undefined;
823	856	try expect(@TypeOf(&array, dest) == [*]i32);
...	...	@@ -828,6 +861,7 @@ test "peer resolution of string literals" {
828	861	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
829	862	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
830	863	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	864	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
831	865
832	866	const S = struct {
833	867	const E = enum { a, b, c, d };
...	...	@@ -848,6 +882,7 @@ test "peer resolution of string literals" {
848	882
849	883	test "peer cast [:x]T to []T" {
850	884	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	885	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
851	886
852	887	const S = struct {
853	888	fn doTheTest() !void {
...	...	@@ -863,6 +898,7 @@ test "peer cast [:x]T to []T" {
863	898
864	899	test "peer cast [N:x]T to [N]T" {
865	900	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	901	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
866	902
867	903	const S = struct {
868	904	fn doTheTest() !void {
...	...	@@ -877,6 +913,7 @@ test "peer cast [N:x]T to [N]T" {
877	913
878	914	test "peer cast [N:x]T to [N]T" {
879	915	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	916	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
880	917
881	918	const S = struct {
882	919	fn doTheTest() !void {
...	...	@@ -892,6 +929,7 @@ test "peer cast [N:x]T to [N]T" {
892	929	test "peer cast [:x]T to []T" {
893	930	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
894	931	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	932	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
895	933
896	934	const S = struct {
897	935	fn doTheTest() !void {
...	...	@@ -912,6 +950,7 @@ test "peer cast [:x]T to [*:x]T" {
912	950	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
913	951	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
914	952	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	953	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
915	954
916	955	const S = struct {
917	956	fn doTheTest() !void {
...	...	@@ -931,6 +970,7 @@ test "peer cast [:x]T to [*:x]T" {
931	970
932	971	test "peer type resolution implicit cast to return type" {
933	972	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	973	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
934	974
935	975	const S = struct {
936	976	fn doTheTest() !void {
...	...	@@ -951,6 +991,7 @@ test "peer type resolution implicit cast to return type" {
951	991	test "peer type resolution implicit cast to variable type" {
952	992	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
953	993	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	994	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
954	995
955	996	const S = struct {
956	997	fn doTheTest() !void {
...	...	@@ -974,6 +1015,7 @@ test "variable initialization uses result locations properly with regards to the
974	1015
975	1016	test "cast between C pointer with different but compatible types" {
976	1017	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1018	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
977	1019
978	1020	const S = struct {
979	1021	fn foo(arg: [*]c_ushort) u16 {
...	...	@@ -990,6 +1032,7 @@ test "cast between C pointer with different but compatible types" {
990	1032
991	1033	test "peer type resolve string lit with sentinel-terminated mutable slice" {
992	1034	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1035	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
993	1036
994	1037	var array: [4:0]u8 = undefined;
995	1038	array[4] = 0; // TODO remove this when #4372 is solved
...	...	@@ -1038,6 +1081,7 @@ test "comptime float casts" {
1038	1081
1039	1082	test "pointer reinterpret const float to int" {
1040	1083	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1084	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1041	1085
1042	1086	// The hex representation is 0x3fe3333333333303.
1043	1087	const float: f64 = 5.99999999999994648725e-01;
...	...	@@ -1053,6 +1097,7 @@ test "pointer reinterpret const float to int" {
1053	1097	test "implicit cast from []T to ?anyopaque" {
1054	1098	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1055	1099	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1056	1101
1057	1102	var a = [_]u8{ 3, 2, 1 };
1058	1103	var runtime_zero: usize = 0;
...	...	@@ -1085,6 +1130,7 @@ fn foobar(func: PFN_void) !void {
1085	1130	test "implicit ptr to *anyopaque" {
1086	1131	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1087	1132	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1133	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1088	1134
1089	1135	var a: u32 = 1;
1090	1136	var ptr: *align(@alignOf(u32)) anyopaque = &a;
...	...	@@ -1097,6 +1143,7 @@ test "implicit ptr to *anyopaque" {
1097	1143
1098	1144	test "return null from fn() anyerror!?&T" {
1099	1145	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1146	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1100	1147
1101	1148	const a = returnNullFromOptionalTypeErrorRef();
1102	1149	const b = returnNullLitFromOptionalTypeErrorRef();
...	...	@@ -1112,6 +1159,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
1112	1159
1113	1160	test "peer type resolution: [0]u8 and []const u8" {
1114	1161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1115	1163
1116	1164	try expect(peerTypeEmptyArrayAndSlice(true, "hi").len == 0);
1117	1165	try expect(peerTypeEmptyArrayAndSlice(false, "hi").len == 1);
...	...	@@ -1132,6 +1180,7 @@ test "implicitly cast from [N]T to ?[]const T" {
1132	1180	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1133	1181	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1134	1182	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1135	1184
1136	1185	try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
1137	1186	comptime try expect(mem.eql(u8, castToOptionalSlice().?, "hi"));
...	...	@@ -1146,6 +1195,7 @@ test "cast u128 to f128 and back" {
1146	1195	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1147	1196	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1148	1197	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1198	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1149	1199
1150	1200	comptime try testCast128();
1151	1201	try testCast128();
...	...	@@ -1167,6 +1217,7 @@ test "implicit cast from [N]T to ?[]T" {
1167	1217	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1168	1218	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1169	1219	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1220	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1170	1221
1171	1222	var x: ?[*]u16 = null;
1172	1223	var y: [4]u16 = [4]u16{ 0, 1, 2, 3 };
...	...	@@ -1181,6 +1232,7 @@ test "implicit cast from [N]T to ?[]T" {
1181	1232	test "implicit cast from T to ?anyopaque" {
1182	1233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1183	1234	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1235	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1184	1236
1185	1237	var a: u8 = 1;
1186	1238	incrementVoidPtrValue(&a);
...	...	@@ -1193,6 +1245,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
1193	1245
1194	1246	test "implicit cast *[0]T to E![]const u8" {
1195	1247	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1248	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1196	1249
1197	1250	var x = @as(anyerror![]const u8, &[0]u8{});
1198	1251	try expect((x catch unreachable).len == 0);
...	...	@@ -1212,6 +1265,7 @@ test "*const [N]null u8 to ?[]const u8" {
1212	1265	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1213	1266	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1214	1267	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1268	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1215	1269
1216	1270	const S = struct {
1217	1271	fn doTheTest() !void {
...	...	@@ -1246,6 +1300,7 @@ var global_struct: struct { f0: usize } = undefined;
1246	1300	test "assignment to optional pointer result loc" {
1247	1301	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1248	1302	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1303	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1249	1304
1250	1305	var foo: struct { ptr: ?*anyopaque } = .{ .ptr = &global_struct };
1251	1306	try expect(foo.ptr.? == @ptrCast(*anyopaque, &global_struct));
...	...	@@ -1259,6 +1314,7 @@ test "cast between *[N]void and []void" {
1259	1314
1260	1315	test "peer resolve arrays of different size to const slice" {
1261	1316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1317	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1262	1318
1263	1319	try expect(mem.eql(u8, boolToStr(true), "true"));
1264	1320	try expect(mem.eql(u8, boolToStr(false), "false"));
...	...	@@ -1274,6 +1330,7 @@ test "cast f16 to wider types" {
1274	1330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1275	1331	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1276	1332	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1333	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1277	1334
1278	1335	const S = struct {
1279	1336	fn doTheTest() !void {
...	...	@@ -1292,6 +1349,7 @@ test "cast f128 to narrower types" {
1292	1349	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1293	1350	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1294	1351	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1352	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1295	1353
1296	1354	const S = struct {
1297	1355	fn doTheTest() !void {
...	...	@@ -1309,6 +1367,7 @@ test "peer type resolution: unreachable, null, slice" {
1309	1367	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1310	1368	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1311	1369	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1312	1371
1313	1372	const S = struct {
1314	1373	fn doTheTest(num: usize, word: []const u8) !void {
...	...	@@ -1325,6 +1384,7 @@ test "peer type resolution: unreachable, null, slice" {
1325	1384
1326	1385	test "cast i8 fn call peers to i32 result" {
1327	1386	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1328	1388
1329	1389	const S = struct {
1330	1390	fn doTheTest() !void {
...	...	@@ -1347,6 +1407,7 @@ test "cast compatible optional types" {
1347	1407	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1348	1408	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1349	1409	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1410	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1350	1411
1351	1412	var a: ?[:0]const u8 = null;
1352	1413	var b: ?[]const u8 = a;
...	...	@@ -1355,6 +1416,7 @@ test "cast compatible optional types" {
1355	1416
1356	1417	test "coerce undefined single-item pointer of array to error union of slice" {
1357	1418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1358	1420
1359	1421	const a = @as([*]u8, undefined)[0..0];
1360	1422	var b: error{a}![]const u8 = a;
...	...	@@ -1363,6 +1425,8 @@ test "coerce undefined single-item pointer of array to error union of slice" {
1363	1425	}
1364	1426
1365	1427	test "pointer to empty struct literal to mutable slice" {
	1428	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1429
1366	1430	var x: []i32 = &.{};
1367	1431	try expect(x.len == 0);
1368	1432	}
...	...	@@ -1372,6 +1436,7 @@ test "coerce between pointers of compatible differently-named floats" {
1372	1436	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1373	1437	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1374	1438	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1439	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1375	1440
1376	1441	if (builtin.os.tag == .windows) {
1377	1442	// https://github.com/ziglang/zig/issues/12396
...	...	@@ -1402,6 +1467,7 @@ test "peer type resolution of const and non-const pointer to array" {
1402	1467	test "floatToInt to zero-bit int" {
1403	1468	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1404	1469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1405	1471
1406	1472	var a: f32 = 0.0;
1407	1473	comptime try std.testing.expect(@floatToInt(u0, a) == 0);

test/behavior/cast_int.zig+1

...	...	@@ -8,6 +8,7 @@ test "@intCast i32 to u7" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	var x: u128 = maxInt(u128);
13	14	var y: i32 = 120;

test/behavior/const_slice_child.zig+1

...	...	@@ -9,6 +9,7 @@ var argv: []const []const u8 = undefined;
9	9	test "const slice child" {
10	10	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	const strs = [_][*]const u8{ "one", "two", "three" };
14	15	argv = &strs;

test/behavior/defer.zig+5

...	...	@@ -33,6 +33,7 @@ test "defer and labeled break" {
33	33
34	34	test "errdefer does not apply to fn inside fn" {
35	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36	37
37	38	if (testNestedFnErrDefer()) \|_\| @panic("expected error") else \|e\| try expect(e == error.Bad);
38	39	}
...	...	@@ -52,6 +53,7 @@ test "return variable while defer expression in scope to modify it" {
52	53	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
53	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
55	57
56	58	const S = struct {
57	59	fn doTheTest() !void {
...	...	@@ -92,6 +94,7 @@ fn runSomeErrorDefers(x: bool) !bool {
92	94	test "mixing normal and error defers" {
93	95	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
94	96	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	97	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
95	98
96	99	try expect(runSomeErrorDefers(true) catch unreachable);
97	100	try expect(result[0] == 'c');
...	...	@@ -111,6 +114,7 @@ test "errdefer with payload" {
111	114	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
112	115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
113	116	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	117	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
114	118
115	119	const S = struct {
116	120	fn foo() !i32 {
...	...	@@ -129,6 +133,7 @@ test "errdefer with payload" {
129	133
130	134	test "simple else prong doesn't emit an error for unreachable else prong" {
131	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
132	137
133	138	const S = struct {
134	139	fn foo() error{Foo}!void {

test/behavior/enum.zig+17

...	...	@@ -26,6 +26,7 @@ const IntToEnumNumber = enum { Zero, One, Two, Three, Four };
26	26
27	27	test "int to enum" {
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29	30
30	31	try testIntToEnumEval(3);
31	32	}
...	...	@@ -607,6 +608,7 @@ fn testEnumWithSpecifiedTagValues(x: MultipleChoice) !void {
607	608
608	609	test "enum with specified tag values" {
609	610	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	611	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
610	612
611	613	try testEnumWithSpecifiedTagValues(MultipleChoice.C);
612	614	comptime try testEnumWithSpecifiedTagValues(MultipleChoice.C);
...	...	@@ -614,6 +616,7 @@ test "enum with specified tag values" {
614	616
615	617	test "non-exhaustive enum" {
616	618	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	619	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
617	620
618	621	const S = struct {
619	622	const E = enum(u8) { a, b, _ };
...	...	@@ -676,6 +679,7 @@ test "empty non-exhaustive enum" {
676	679
677	680	test "single field non-exhaustive enum" {
678	681	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	682	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
679	683
680	684	const S = struct {
681	685	const E = enum(u8) { a, _ };
...	...	@@ -739,6 +743,7 @@ test "cast integer literal to enum" {
739	743
740	744	test "enum with specified and unspecified tag values" {
741	745	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	746	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
742	747
743	748	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
744	749	comptime try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2.D);
...	...	@@ -898,6 +903,7 @@ test "enum value allocation" {
898	903	test "enum literal casting to tagged union" {
899	904	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
900	905	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	906	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
901	907
902	908	const Arch = union(enum) {
903	909	x86_64,
...	...	@@ -922,6 +928,7 @@ const Bar = enum { A, B, C, D };
922	928
923	929	test "enum literal casting to error union with payload enum" {
924	930	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	931	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
925	932
926	933	var bar: error{B}!Bar = undefined;
927	934	bar = .B; // should never cast to the error set
...	...	@@ -933,6 +940,7 @@ test "constant enum initialization with differing sizes" {
933	940	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
934	941	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
935	942	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	943	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
936	944
937	945	try test3_1(test3_foo);
938	946	try test3_2(test3_bar);
...	...	@@ -976,6 +984,7 @@ test "@tagName" {
976	984	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
977	985	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
978	986	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	987	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
979	988
980	989	try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
981	990	comptime try expect(mem.eql(u8, testEnumTagNameBare(BareNumber.Three), "Three"));
...	...	@@ -992,6 +1001,7 @@ test "@tagName non-exhaustive enum" {
992	1001	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
993	1002	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
994	1003	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1004	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
995	1005
996	1006	try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
997	1007	comptime try expect(mem.eql(u8, testEnumTagNameBare(NonExhaustive.B), "B"));
...	...	@@ -1003,6 +1013,7 @@ test "@tagName is null-terminated" {
1003	1013	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1004	1014	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1005	1015	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1016	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1006	1017
1007	1018	const S = struct {
1008	1019	fn doTheTest(n: BareNumber) !void {
...	...	@@ -1018,6 +1029,7 @@ test "tag name with assigned enum values" {
1018	1029	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1019	1030	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1020	1031	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1032	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1021	1033
1022	1034	const LocalFoo = enum(u8) {
1023	1035	A = 1,
...	...	@@ -1029,6 +1041,7 @@ test "tag name with assigned enum values" {
1029	1041
1030	1042	test "@tagName on enum literals" {
1031	1043	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1044	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1032	1045
1033	1046	try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
1034	1047	comptime try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
...	...	@@ -1037,6 +1050,7 @@ test "@tagName on enum literals" {
1037	1050	test "enum literal casting to optional" {
1038	1051	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1039	1052	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1053	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1040	1054
1041	1055	var bar: ?Bar = undefined;
1042	1056	bar = .B;
...	...	@@ -1065,6 +1079,7 @@ test "bit field access with enum fields" {
1065	1079	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1066	1080	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1067	1081	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1082	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1068	1083
1069	1084	var data = bit_field_1;
1070	1085	try expect(getA(&data) == A.Two);
...	...	@@ -1105,6 +1120,7 @@ test "tag name functions are unique" {
1105	1120	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1106	1121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1107	1122	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1108	1124
1109	1125	{
1110	1126	const E = enum { a, b };
...	...	@@ -1123,6 +1139,7 @@ test "tag name functions are unique" {
1123	1139	test "size of enum with only one tag which has explicit integer tag type" {
1124	1140	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1125	1141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	1142	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1126	1143
1127	1144	const E = enum(u8) { nope = 10 };
1128	1145	const S0 = struct { e: E };

test/behavior/error.zig+31

...	...	@@ -30,6 +30,7 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
30	30
31	31	test "error binary operator" {
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33	34
34	35	const a = errBinaryOperatorG(true) catch 3;
35	36	const b = errBinaryOperatorG(false) catch 3;
...	...	@@ -61,12 +62,14 @@ pub fn baz() anyerror!i32 {
61	62
62	63	test "error wrapping" {
63	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
64	66
65	67	try expect((baz() catch unreachable) == 15);
66	68	}
67	69
68	70	test "unwrap simple value from error" {
69	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
70	73
71	74	const i = unwrapSimpleValueFromErrorDo() catch unreachable;
72	75	try expect(i == 13);
...	...	@@ -77,6 +80,7 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
77	80
78	81	test "error return in assignment" {
79	82	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80	84
81	85	doErrReturnInAssignment() catch unreachable;
82	86	}
...	...	@@ -99,6 +103,7 @@ test "syntax: optional operator in front of error union operator" {
99	103	test "widen cast integer payload of error union function call" {
100	104	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
101	105	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	106	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
102	107
103	108	const S = struct {
104	109	fn errorable() !u64 {
...	...	@@ -115,6 +120,7 @@ test "widen cast integer payload of error union function call" {
115	120
116	121	test "debug info for optional error set" {
117	122	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	123	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
118	124
119	125	const SomeError = error{ Hello, Hello2 };
120	126	var a_local_variable: ?SomeError = null;
...	...	@@ -123,6 +129,7 @@ test "debug info for optional error set" {
123	129
124	130	test "implicit cast to optional to error union to return result loc" {
125	131	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
126	133
127	134	const S = struct {
128	135	fn entry() !void {
...	...	@@ -242,6 +249,7 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
242	249	test "comptime test error for empty error set" {
243	250	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
244	251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	252	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
245	253
246	254	try testComptimeTestErrorEmptySet(1234);
247	255	comptime try testComptimeTestErrorEmptySet(1234);
...	...	@@ -281,6 +289,7 @@ test "inferred empty error set comptime catch" {
281	289
282	290	test "error union peer type resolution" {
283	291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
284	293
285	294	try testErrorUnionPeerTypeResolution(1);
286	295	}
...	...	@@ -312,6 +321,7 @@ fn quux_1() !i32 {
312	321
313	322	test "error: Zero sized error set returned with value payload crash" {
314	323	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	324	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
315	325
316	326	_ = try foo3(0);
317	327	_ = comptime try foo3(0);
...	...	@@ -324,6 +334,7 @@ fn foo3(b: usize) Error!usize {
324	334
325	335	test "error: Infer error set from literals" {
326	336	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	337	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
327	338
328	339	_ = nullLiteral("n") catch \|err\| handleErrors(err);
329	340	_ = floatLiteral("n") catch \|err\| handleErrors(err);
...	...	@@ -363,6 +374,7 @@ test "nested error union function call in optional unwrap" {
363	374	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
364	375	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
365	376	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	377	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
366	378
367	379	const S = struct {
368	380	const Foo = struct {
...	...	@@ -409,6 +421,7 @@ test "nested error union function call in optional unwrap" {
409	421	test "return function call to error set from error union function" {
410	422	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
411	423	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	424	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
412	425
413	426	const S = struct {
414	427	fn errorable() anyerror!i32 {
...	...	@@ -426,6 +439,7 @@ test "return function call to error set from error union function" {
426	439	test "optional error set is the same size as error set" {
427	440	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
428	441	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	442	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
429	443
430	444	comptime try expect(@sizeOf(?anyerror) == @sizeOf(anyerror));
431	445	comptime try expect(@alignOf(?anyerror) == @alignOf(anyerror));
...	...	@@ -441,6 +455,7 @@ test "optional error set is the same size as error set" {
441	455	test "nested catch" {
442	456	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
443	457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	458	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
444	459
445	460	const S = struct {
446	461	fn entry() !void {
...	...	@@ -466,6 +481,7 @@ test "nested catch" {
466	481	test "function pointer with return type that is error union with payload which is pointer of parent struct" {
467	482	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
468	483	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	484	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
469	485
470	486	const S = struct {
471	487	const Foo = struct {
...	...	@@ -491,6 +507,7 @@ test "return result loc as peer result loc in inferred error set function" {
491	507	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
492	508	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
493	509	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	510	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
494	511
495	512	const S = struct {
496	513	fn doTheTest() !void {
...	...	@@ -522,6 +539,7 @@ test "error payload type is correctly resolved" {
522	539	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
523	540	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
524	541	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	542	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
525	543
526	544	const MyIntWrapper = struct {
527	545	const Self = @This();
...	...	@@ -551,6 +569,7 @@ test "@errorName" {
551	569	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
552	570	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
553	571	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	572	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
554	573
555	574	try expect(mem.eql(u8, @errorName(error.AnError), "AnError"));
556	575	try expect(mem.eql(u8, @errorName(error.ALongerErrorName), "ALongerErrorName"));
...	...	@@ -564,6 +583,7 @@ test "@errorName sentinel length matches slice length" {
564	583	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
565	584	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
566	585	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	586	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
567	587
568	588	const name = testBuiltinErrorName(error.FooBar);
569	589	const length: usize = 6;
...	...	@@ -592,6 +612,7 @@ test "error set equality" {
592	612
593	613	test "inferred error set equality" {
594	614	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	615	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
595	616
596	617	const S = struct {
597	618	fn foo() !void {
...	...	@@ -655,6 +676,7 @@ test "error union payload is properly aligned" {
655	676	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
656	677	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
657	678	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	679	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
658	680
659	681	const S = struct {
660	682	a: u128,
...	...	@@ -670,6 +692,7 @@ test "error union payload is properly aligned" {
670	692
671	693	test "ret_ptr doesn't cause own inferred error set to be resolved" {
672	694	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	695	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
673	696
674	697	const S = struct {
675	698	fn foo() !void {}
...	...	@@ -686,6 +709,7 @@ test "ret_ptr doesn't cause own inferred error set to be resolved" {
686	709	test "simple else prong allowed even when all errors handled" {
687	710	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
688	711	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	712	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
689	713
690	714	const S = struct {
691	715	fn foo() !u8 {
...	...	@@ -714,6 +738,7 @@ test "pointer to error union payload" {
714	738	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
715	739	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
716	740	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	741	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
717	742
718	743	var err_union: anyerror!u8 = 15;
719	744
...	...	@@ -747,6 +772,7 @@ test "error union of noreturn used with if" {
747	772	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
748	773	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
749	774	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	775	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
750	776
751	777	NoReturn.a = 64;
752	778	if (NoReturn.loop()) {
...	...	@@ -761,6 +787,7 @@ test "error union of noreturn used with try" {
761	787	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
762	788	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
763	789	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	790	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
764	791
765	792	NoReturn.a = 64;
766	793	const err = NoReturn.testTry();
...	...	@@ -772,6 +799,7 @@ test "error union of noreturn used with catch" {
772	799	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
773	800	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
774	801	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	802	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
775	803
776	804	NoReturn.a = 64;
777	805	const err = NoReturn.testCatch();
...	...	@@ -782,6 +810,7 @@ test "alignment of wrapping an error union payload" {
782	810	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
783	811	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
784	812	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	813	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
785	814
786	815	const S = struct {
787	816	const I = extern struct { x: i128 };
...	...	@@ -796,6 +825,7 @@ test "alignment of wrapping an error union payload" {
796	825
797	826	test "compare error union and error set" {
798	827	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	828	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
799	829
800	830	var a: anyerror = error.Foo;
801	831	var b: anyerror!u32 = error.Bar;
...	...	@@ -831,6 +861,7 @@ test "error from comptime string" {
831	861	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
832	862	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
833	863	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	864	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
834	865
835	866	const name = "Weird error name!";
836	867	const S = struct {

test/behavior/eval.zig+44

...	...	@@ -20,6 +20,7 @@ const should_be_1235 = unwrapAndAddOne(1234);
20	20	test "static add one" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	24
24	25	try expect(should_be_1235 == 1235);
25	26	}
...	...	@@ -70,6 +71,7 @@ fn constExprEvalOnSingleExprBlocksFn(x: i32, b: bool) i32 {
70	71
71	72	test "constant expressions" {
72	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	74	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73	75
74	76	var array: [array_size]u8 = undefined;
75	77	try expect(@sizeOf(@TypeOf(array)) == 20);
...	...	@@ -90,6 +92,7 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
90	92	}
91	93	test "inlined block and runtime block phi" {
92	94	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	95	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
93	96
94	97	try expect(letsTryToCompareBools(true, true));
95	98	try expect(letsTryToCompareBools(true, false));
...	...	@@ -137,6 +140,7 @@ test "pointer to type" {
137	140	test "a type constructed in a global expression" {
138	141	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
139	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	143	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
140	144
141	145	var l: List = undefined;
142	146	l.array[0] = 10;
...	...	@@ -232,6 +236,7 @@ const vertices = [_]Vertex{
232	236
233	237	test "statically initialized list" {
234	238	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
235	240
236	241	try expect(static_point_list[0].x == 1);
237	242	try expect(static_point_list[0].y == 2);
...	...	@@ -337,6 +342,7 @@ fn doesAlotT(comptime T: type, value: usize) T {
337	342
338	343	test "@setEvalBranchQuota at same scope as generic function call" {
339	344	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	345	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
340	346
341	347	try expect(doesAlotT(u32, 2) == 2);
342	348	}
...	...	@@ -387,6 +393,7 @@ test "return 0 from function that has u0 return type" {
387	393
388	394	test "statically initialized struct" {
389	395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	396	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
390	397
391	398	st_init_str_foo.x += 1;
392	399	try expect(st_init_str_foo.x == 14);
...	...	@@ -435,6 +442,7 @@ fn copyWithPartialInline(s: []u32, b: []u8) void {
435	442	test "binary math operator in partially inlined function" {
436	443	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
437	444	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	445	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
438	446
439	447	var s: [4]u32 = undefined;
440	448	var b: [16]u8 = undefined;
...	...	@@ -454,6 +462,7 @@ test "comptime shl" {
454	462	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
455	463	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
456	464	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	465	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
457	466
458	467	var a: u128 = 3;
459	468	var b: u7 = 63;
...	...	@@ -498,6 +507,7 @@ test "comptime shlWithOverflow" {
498	507
499	508	test "const ptr to variable data changes at runtime" {
500	509	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	510	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
501	511
502	512	try expect(foo_ref.name[0] == 'a');
503	513	foo_ref.name = "b";
...	...	@@ -516,6 +526,7 @@ test "runtime 128 bit integer division" {
516	526	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
517	527	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
518	528	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
519	530
520	531	var a: u128 = 152313999999999991610955792383;
521	532	var b: u128 = 10000000000000000000;
...	...	@@ -525,6 +536,7 @@ test "runtime 128 bit integer division" {
525	536
526	537	test "@tagName of @typeInfo" {
527	538	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	539	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
528	540
529	541	const str = @tagName(@typeInfo(u8));
530	542	try expect(std.mem.eql(u8, str, "Int"));
...	...	@@ -534,6 +546,7 @@ test "static eval list init" {
534	546	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
535	547	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
536	548	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	549	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
537	550
538	551	try expect(static_vec3.data[2] == 1.0);
539	552	try expect(vec3(0.0, 0.0, 3.0).data[2] == 3.0);
...	...	@@ -549,6 +562,8 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
549	562	}
550	563
551	564	test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
	565	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	566
552	567	var runtime = [1]i32{3};
553	568	comptime var i: usize = 0;
554	569	inline while (i < 2) : (i += 1) {
...	...	@@ -562,6 +577,7 @@ test "inlined loop has array literal with elided runtime scope on first iteratio
562	577
563	578	test "ptr to local array argument at comptime" {
564	579	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	580	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
565	581
566	582	comptime {
567	583	var bytes: [10]u8 = undefined;
...	...	@@ -597,6 +613,8 @@ fn testCompTimeUIntComparisons(x: u32) void {
597	613	const hi1 = "hi";
598	614	const hi2 = hi1;
599	615	test "const global shares pointer with other same one" {
	616	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	617
600	618	try assertEqualPtrs(&hi1[0], &hi2[0]);
601	619	comptime try expect(&hi1[0] == &hi2[0]);
602	620	}
...	...	@@ -721,6 +739,7 @@ test "align(1) u16 is the same as align(1:0:2) u16" {
721	739	test "array concatenation of function calls" {
722	740	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
723	741	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	742	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
724	743
725	744	var a = oneItem(3) ++ oneItem(4);
726	745	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 4 }));
...	...	@@ -729,6 +748,7 @@ test "array concatenation of function calls" {
729	748	test "array multiplication of function calls" {
730	749	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
731	750	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	751	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
732	752
733	753	var a = oneItem(3) ** scalar(2);
734	754	try expect(std.mem.eql(i32, &a, &[_]i32{ 3, 3 }));
...	...	@@ -745,6 +765,7 @@ fn scalar(x: u32) u32 {
745	765	test "array concatenation peer resolves element types - value" {
746	766	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
747	767	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	768	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
748	769
749	770	var a = [2]u3{ 1, 7 };
750	771	var b = [3]u8{ 200, 225, 255 };
...	...	@@ -760,6 +781,7 @@ test "array concatenation peer resolves element types - value" {
760	781	test "array concatenation peer resolves element types - pointer" {
761	782	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
762	783	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	784	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
763	785
764	786	var a = [2]u3{ 1, 7 };
765	787	var b = [3]u8{ 200, 225, 255 };
...	...	@@ -777,6 +799,7 @@ test "array concatenation sets the sentinel - value" {
777	799	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
778	800	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
779	801	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	802	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
780	803
781	804	var a = [2]u3{ 1, 7 };
782	805	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -793,6 +816,7 @@ test "array concatenation sets the sentinel - value" {
793	816
794	817	test "array concatenation sets the sentinel - pointer" {
795	818	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	819	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
796	820
797	821	var a = [2]u3{ 1, 7 };
798	822	var b = [3:69]u8{ 200, 225, 255 };
...	...	@@ -812,6 +836,7 @@ test "array multiplication sets the sentinel - value" {
812	836	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
813	837	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
814	838	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	839	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
815	840
816	841	var a = [2:7]u3{ 1, 6 };
817	842	var b = a ** 2;
...	...	@@ -827,6 +852,7 @@ test "array multiplication sets the sentinel - value" {
827	852	test "array multiplication sets the sentinel - pointer" {
828	853	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
829	854	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	855	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
830	856
831	857	var a = [2:7]u3{ 1, 6 };
832	858	var b = &a ** 2;
...	...	@@ -851,6 +877,7 @@ test "comptime assign int to optional int" {
851	877	test "two comptime calls with array default initialized to undefined" {
852	878	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
853	879	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	880	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
854	881
855	882	const S = struct {
856	883	const CrossTarget = struct {
...	...	@@ -935,6 +962,7 @@ test "const local with comptime init through array init" {
935	962
936	963	test "closure capture type of runtime-known parameter" {
937	964	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	965	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
938	966
939	967	const S = struct {
940	968	fn b(c: anytype) !void {
...	...	@@ -949,6 +977,7 @@ test "closure capture type of runtime-known parameter" {
949	977
950	978	test "comptime break passing through runtime condition converted to runtime break" {
951	979	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	980	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
952	981
953	982	const S = struct {
954	983	fn doTheTest() !void {
...	...	@@ -982,6 +1011,7 @@ test "comptime break to outer loop passing through runtime condition converted t
982	1011	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
983	1012	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
984	1013	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
985	1015
986	1016	const S = struct {
987	1017	fn doTheTest() !void {
...	...	@@ -1032,6 +1062,7 @@ test "comptime break operand passing through runtime condition converted to runt
1032	1062
1033	1063	test "comptime break operand passing through runtime switch converted to runtime break" {
1034	1064	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1065	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1035	1066
1036	1067	const S = struct {
1037	1068	fn doTheTest(runtime: u8) !void {
...	...	@@ -1051,6 +1082,7 @@ test "comptime break operand passing through runtime switch converted to runtime
1051	1082
1052	1083	test "no dependency loop for alignment of self struct" {
1053	1084	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1085	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1054	1086
1055	1087	const S = struct {
1056	1088	fn doTheTest() !void {
...	...	@@ -1087,6 +1119,7 @@ test "no dependency loop for alignment of self struct" {
1087	1119
1088	1120	test "no dependency loop for alignment of self bare union" {
1089	1121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1122	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1090	1123
1091	1124	const S = struct {
1092	1125	fn doTheTest() !void {
...	...	@@ -1123,6 +1156,7 @@ test "no dependency loop for alignment of self bare union" {
1123	1156
1124	1157	test "no dependency loop for alignment of self tagged union" {
1125	1158	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1159	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1126	1160
1127	1161	const S = struct {
1128	1162	fn doTheTest() !void {
...	...	@@ -1166,6 +1200,7 @@ test "storing an array of type in a field" {
1166	1200	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1167	1201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1168	1202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1203	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1169	1204
1170	1205	const S = struct {
1171	1206	fn doTheTest() void {
...	...	@@ -1194,6 +1229,7 @@ test "storing an array of type in a field" {
1194	1229	test "pass pointer to field of comptime-only type as a runtime parameter" {
1195	1230	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1196	1231	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1232	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1197	1233
1198	1234	const S = struct {
1199	1235	const Mixed = struct {
...	...	@@ -1309,6 +1345,7 @@ test "lazy sizeof is resolved in division" {
1309	1345
1310	1346	test "lazy value is resolved as slice operand" {
1311	1347	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1348	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1312	1349
1313	1350	const A = struct { a: u32 };
1314	1351	var a: [512]u64 = undefined;
...	...	@@ -1365,6 +1402,8 @@ test "inline for inside a runtime condition" {
1365	1402	}
1366	1403
1367	1404	test "continue in inline for inside a comptime switch" {
	1405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1406
1368	1407	const arr = .{ 1, 2, 3 };
1369	1408	var count: u8 = 0;
1370	1409	switch (arr[1]) {
...	...	@@ -1428,6 +1467,8 @@ test "continue nested inline for loop in named block expr" {
1428	1467	}
1429	1468
1430	1469	test "x and false is comptime-known false" {
	1470	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1471
1431	1472	const T = struct {
1432	1473	var x: u32 = 0;
1433	1474
...	...	@@ -1453,6 +1494,8 @@ test "x and false is comptime-known false" {
1453	1494	}
1454	1495
1455	1496	test "x or true is comptime-known true" {
	1497	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	1498
1456	1499	const T = struct {
1457	1500	var x: u32 = 0;
1458	1501
...	...	@@ -1482,6 +1525,7 @@ test "non-optional and optional array elements concatenated" {
1482	1525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1483	1526	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1484	1527	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1528	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1485	1529
1486	1530	const array = [1]u8{'A'} ++ [1]?u8{null};
1487	1531	var index: usize = 0;

test/behavior/export.zig+2

...	...	@@ -22,6 +22,8 @@ const PackedUnion = packed union {
22	22	};
23	23
24	24	test "packed struct, enum, union parameters in extern function" {
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26
25	27	testPackedStuff(&(PackedStruct{
26	28	.a = 1,
27	29	.b = 2,

test/behavior/field_parent_ptr.zig+2

...	...	@@ -4,6 +4,7 @@ const builtin = @import("builtin");
4	4	test "@fieldParentPtr non-first field" {
5	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6	6	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	8	try testParentFieldPtr(&foo.c);
8	9	comptime try testParentFieldPtr(&foo.c);
9	10	}
...	...	@@ -11,6 +12,7 @@ test "@fieldParentPtr non-first field" {
11	12	test "@fieldParentPtr first field" {
12	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	15	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14	16	try testParentFieldPtrFirst(&foo.a);
15	17	comptime try testParentFieldPtrFirst(&foo.a);
16	18	}

test/behavior/floatop.zig+30

...	...	@@ -22,6 +22,7 @@ fn epsForType(comptime T: type) T {
22	22	test "floating point comparisons" {
23	23	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
25	26
26	27	try testFloatComparisons();
27	28	comptime try testFloatComparisons();
...	...	@@ -57,6 +58,7 @@ test "different sized float comparisons" {
57	58	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
58	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
59	60	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
60	62
61	63	try testDifferentSizedFloatComparisons();
62	64	comptime try testDifferentSizedFloatComparisons();
...	...	@@ -91,6 +93,7 @@ test "negative f128 floatToInt at compile-time" {
91	93	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
92	94	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
93	95	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	96	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
94	97
95	98	const a: f128 = -2;
96	99	var b = @floatToInt(i64, a);
...	...	@@ -102,6 +105,7 @@ test "@sqrt" {
102	105	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
103	106	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
104	107	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	108	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
105	109
106	110	comptime try testSqrt();
107	111	try testSqrt();
...	...	@@ -160,6 +164,7 @@ test "more @sqrt f16 tests" {
160	164	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
161	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	166	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	168
164	169	// TODO these are not all passing at comptime
165	170	try expect(@sqrt(@as(f16, 0.0)) == 0.0);
...	...	@@ -185,6 +190,7 @@ test "@sin" {
185	190	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
186	191	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
187	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	193	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188	194
189	195	comptime try testSin();
190	196	try testSin();
...	...	@@ -225,6 +231,7 @@ test "@cos" {
225	231	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
226	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
227	233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
228	235
229	236	comptime try testCos();
230	237	try testCos();
...	...	@@ -265,6 +272,7 @@ test "@exp" {
265	272	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
266	273	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
267	274	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	275	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
268	276
269	277	comptime try testExp();
270	278	try testExp();
...	...	@@ -304,6 +312,7 @@ test "@exp2" {
304	312	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
305	313	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
306	314	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	315	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
307	316
308	317	comptime try testExp2();
309	318	try testExp2();
...	...	@@ -343,6 +352,7 @@ test "@log" {
343	352	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
344	353	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
345	354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
346	356
347	357	comptime try testLog();
348	358	try testLog();
...	...	@@ -374,6 +384,7 @@ test "@log with @vectors" {
374	384	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
375	385	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
376	386	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	387	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
377	388
378	389	{
379	390	var v: @Vector(4, f32) = [_]f32{ 1.1, 2.2, 0.3, 0.4 };
...	...	@@ -390,6 +401,7 @@ test "@log2" {
390	401	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
391	402	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
392	403	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	404	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
393	405
394	406	comptime try testLog2();
395	407	try testLog2();
...	...	@@ -433,6 +445,7 @@ test "@log10" {
433	445	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
434	446	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
435	447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	448	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
436	449
437	450	comptime try testLog10();
438	451	try testLog10();
...	...	@@ -472,6 +485,7 @@ test "@fabs" {
472	485	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
473	486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
474	487	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	488	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
475	489
476	490	comptime try testFabs();
477	491	try testFabs();
...	...	@@ -520,6 +534,7 @@ test "@floor" {
520	534	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
521	535	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
522	536	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	537	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
523	538
524	539	comptime try testFloor();
525	540	try testFloor();
...	...	@@ -563,6 +578,7 @@ test "@ceil" {
563	578	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
564	579	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
565	580	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	581	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
566	582
567	583	comptime try testCeil();
568	584	try testCeil();
...	...	@@ -606,6 +622,7 @@ test "@trunc" {
606	622	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
607	623	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
608	624	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	625	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
609	626
610	627	comptime try testTrunc();
611	628	try testTrunc();
...	...	@@ -649,6 +666,7 @@ test "negation f16" {
649	666	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
650	667	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
651	668	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	669	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
652	670
653	671	if (builtin.os.tag == .freebsd) {
654	672	// TODO file issue to track this failure
...	...	@@ -674,6 +692,7 @@ test "negation f32" {
674	692	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
675	693	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
676	694	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	695	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
677	696
678	697	const S = struct {
679	698	fn doTheTest() !void {
...	...	@@ -694,6 +713,7 @@ test "negation f64" {
694	713	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
695	714	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
696	715	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	716	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
697	717
698	718	const S = struct {
699	719	fn doTheTest() !void {
...	...	@@ -714,6 +734,7 @@ test "negation f80" {
714	734	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
715	735	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
716	736	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	737	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
717	738
718	739	const S = struct {
719	740	fn doTheTest() !void {
...	...	@@ -734,6 +755,7 @@ test "negation f128" {
734	755	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
735	756	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
736	757	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	758	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
737	759
738	760	const S = struct {
739	761	fn doTheTest() !void {
...	...	@@ -751,6 +773,7 @@ test "negation f128" {
751	773
752	774	test "eval @setFloatMode at compile-time" {
753	775	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	776	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
754	777
755	778	const result = comptime fnWithFloatMode();
756	779	try expect(result == 1234.0);
...	...	@@ -775,6 +798,7 @@ test "comptime fixed-width float zero divided by zero produces NaN" {
775	798	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
776	799	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
777	800	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	801	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
778	802
779	803	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
780	804	try expect(math.isNan(@as(F, 0) / @as(F, 0)));
...	...	@@ -786,6 +810,7 @@ test "comptime fixed-width float non-zero divided by zero produces signed Inf" {
786	810	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
787	811	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
788	812	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	813	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
789	814
790	815	inline for (.{ f16, f32, f64, f80, f128 }) \|F\| {
791	816	const pos = @as(F, 1) / @as(F, 0);
...	...	@@ -806,6 +831,7 @@ test "nan negation f16" {
806	831	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
807	832	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
808	833	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	834	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
809	835
810	836	const nan_comptime = comptime math.nan(f16);
811	837	const neg_nan_comptime = -nan_comptime;
...	...	@@ -825,6 +851,7 @@ test "nan negation f32" {
825	851	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
826	852	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
827	853	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	854	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
828	855
829	856	const nan_comptime = comptime math.nan(f32);
830	857	const neg_nan_comptime = -nan_comptime;
...	...	@@ -844,6 +871,7 @@ test "nan negation f64" {
844	871	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
845	872	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
846	873	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	874	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
847	875
848	876	const nan_comptime = comptime math.nan(f64);
849	877	const neg_nan_comptime = -nan_comptime;
...	...	@@ -863,6 +891,7 @@ test "nan negation f128" {
863	891	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
864	892	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
865	893	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	894	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
866	895
867	896	const nan_comptime = comptime math.nan(f128);
868	897	const neg_nan_comptime = -nan_comptime;
...	...	@@ -882,6 +911,7 @@ test "nan negation f80" {
882	911	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
883	912	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
884	913	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	914	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
885	915
886	916	const nan_comptime = comptime math.nan(f80);
887	917	const neg_nan_comptime = -nan_comptime;

test/behavior/fn.zig+19

...	...	@@ -75,6 +75,7 @@ test "return inner function which references comptime variable of outer function
75	75	test "discard the result of a function that returns a struct" {
76	76	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
77	77	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	78	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
78	79
79	80	const S = struct {
80	81	fn entry() void {
...	...	@@ -98,6 +99,7 @@ test "inline function call that calls optional function pointer, return pointer
98	99	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
99	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
100	101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
101	103
102	104	const S = struct {
103	105	field: u32,
...	...	@@ -173,11 +175,14 @@ fn fComplexCallconvRet(x: u32) callconv(blk: {
173	175	test "function with complex callconv and return type expressions" {
174	176	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
175	177	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
176	179
177	180	try expect(fComplexCallconvRet(3).x == 9);
178	181	}
179	182
180	183	test "pass by non-copying value" {
	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	185
181	186	try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
182	187	}
183	188
...	...	@@ -192,6 +197,7 @@ fn addPointCoords(pt: Point) i32 {
192	197
193	198	test "pass by non-copying value through var arg" {
194	199	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
195	201
196	202	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);
197	203	}
...	...	@@ -202,6 +208,8 @@ fn addPointCoordsVar(pt: anytype) !i32 {
202	208	}
203	209
204	210	test "pass by non-copying value as method" {
	211	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	212
205	213	var pt = Point2{ .x = 1, .y = 2 };
206	214	try expect(pt.addPointCoords() == 3);
207	215	}
...	...	@@ -216,6 +224,8 @@ const Point2 = struct {
216	224	};
217	225
218	226	test "pass by non-copying value as method, which is generic" {
	227	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	228
219	229	var pt = Point3{ .x = 1, .y = 2 };
220	230	try expect(pt.addPointCoords(i32) == 3);
221	231	}
...	...	@@ -231,6 +241,8 @@ const Point3 = struct {
231	241	};
232	242
233	243	test "pass by non-copying value as method, at comptime" {
	244	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	245
234	246	comptime {
235	247	var pt = Point2{ .x = 1, .y = 2 };
236	248	try expect(pt.addPointCoords() == 3);
...	...	@@ -240,6 +252,7 @@ test "pass by non-copying value as method, at comptime" {
240	252	test "implicit cast fn call result to optional in field result" {
241	253	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
242	254	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	255	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
243	256
244	257	const S = struct {
245	258	fn entry() !void {
...	...	@@ -280,6 +293,7 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
280	293
281	294	test "call function with empty string" {
282	295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	296	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
283	297
284	298	acceptsString("");
285	299	}
...	...	@@ -292,6 +306,7 @@ test "function pointers" {
292	306	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
293	307	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
294	308	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	309	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295	310
296	311	const fns = [_]*const @TypeOf(fn1){
297	312	&fn1,
...	...	@@ -329,6 +344,7 @@ test "function call with anon list literal" {
329	344	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
330	345	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
331	346	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	347	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
332	348
333	349	const S = struct {
334	350	fn doTheTest() !void {
...	...	@@ -349,6 +365,7 @@ test "function call with anon list literal - 2D" {
349	365	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
350	366	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
351	367	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
352	369
353	370	const S = struct {
354	371	fn doTheTest() !void {
...	...	@@ -394,6 +411,7 @@ test "function with inferred error set but returning no error" {
394	411
395	412	test "import passed byref to function in return type" {
396	413	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
397	415
398	416	const S = struct {
399	417	fn get() @import("std").ArrayListUnmanaged(i32) {
...	...	@@ -428,6 +446,7 @@ test "implicit cast function to function ptr" {
428	446	test "method call with optional and error union first param" {
429	447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
430	448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	449	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
431	450
432	451	const S = struct {
433	452	x: i32 = 1234,

test/behavior/fn_delegation.zig+1

...	...	@@ -33,6 +33,7 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
33	33
34	34	test "fn delegation" {
35	35	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
36	37
37	38	const foo = Foo{};
38	39	try expect(foo.one() == 11);

test/behavior/for.zig+8

...	...	@@ -6,6 +6,7 @@ const mem = std.mem;
6	6
7	7	test "continue in for loop" {
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	const array = [_]i32{ 1, 2, 3, 4, 5 };
11	12	var sum: i32 = 0;
...	...	@@ -68,6 +69,7 @@ test "basic for loop" {
68	69	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
69	70	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	71	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	72	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	73
72	74	const expected_result = [_]u8{ 9, 8, 7, 6, 0, 1, 2, 3 } ** 3;
73	75
...	...	@@ -111,6 +113,7 @@ test "for with null and T peer types and inferred result location type" {
111	113	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
112	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
113	115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
114	117
115	118	const S = struct {
116	119	fn doTheTest(slice: []const u8) !void {
...	...	@@ -130,6 +133,7 @@ test "for with null and T peer types and inferred result location type" {
130	133
131	134	test "2 break statements and an else" {
132	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	136	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
133	137
134	138	const S = struct {
135	139	fn entry(t: bool, f: bool) !void {
...	...	@@ -151,6 +155,7 @@ test "for loop with pointer elem var" {
151	155	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
152	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
153	157	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	158	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
154	159
155	160	const source = "abcdefg";
156	161	var target: [source.len]u8 = undefined;
...	...	@@ -176,6 +181,7 @@ fn mangleString(s: []u8) void {
176	181
177	182	test "for copies its payload" {
178	183	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
179	185
180	186	const S = struct {
181	187	fn doTheTest() !void {
...	...	@@ -195,6 +201,7 @@ test "for on slice with allowzero ptr" {
195	201	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
196	202	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
197	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	204	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
198	205
199	206	const S = struct {
200	207	fn doTheTest(slice: []const u8) !void {
...	...	@@ -209,6 +216,7 @@ test "for on slice with allowzero ptr" {
209	216
210	217	test "else continue outer for" {
211	218	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	219	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
212	220
213	221	var i: usize = 6;
214	222	var buf: [5]u8 = undefined;

test/behavior/generics.zig+16

...	...	@@ -18,6 +18,7 @@ fn checkSize(comptime T: type) usize {
18	18
19	19	test "simple generic fn" {
20	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21	22
22	23	try expect(max(i32, 3, -1) == 3);
23	24	try expect(max(u8, 1, 100) == 100);
...	...	@@ -58,6 +59,7 @@ test "fn with comptime args" {
58	59	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
59	60	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
60	61	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	62	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
61	63
62	64	try expect(gimmeTheBigOne(1234, 5678) == 5678);
63	65	try expect(shouldCallSameInstance(34, 12) == 34);
...	...	@@ -68,6 +70,7 @@ test "anytype params" {
68	70	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
69	71	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
70	72	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	74
72	75	try expect(max_i32(12, 34) == 34);
73	76	try expect(max_f64(1.2, 3.4) == 3.4);
...	...	@@ -92,6 +95,7 @@ fn max_f64(a: f64, b: f64) f64 {
92	95	test "type constructed by comptime function call" {
93	96	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
94	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	98	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
95	99
96	100	var l: SimpleList(10) = undefined;
97	101	l.array[0] = 10;
...	...	@@ -114,6 +118,7 @@ fn SimpleList(comptime L: usize) type {
114	118	test "function with return type type" {
115	119	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
117	122
118	123	var list: List(i32) = undefined;
119	124	var list2: List(i32) = undefined;
...	...	@@ -154,6 +159,7 @@ fn aGenericFn(comptime T: type, comptime a: T, b: T) T {
154	159	test "generic fn with implicit cast" {
155	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
156	161	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	162	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157	163
158	164	try expect(getFirstByte(u8, &[_]u8{13}) == 13);
159	165	try expect(getFirstByte(u16, &[_]u16{
...	...	@@ -171,6 +177,7 @@ fn getFirstByte(comptime T: type, mem: []const T) u8 {
171	177	test "generic fn keeps non-generic parameter types" {
172	178	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
173	179	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	180	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
174	181
175	182	const A = 128;
176	183
...	...	@@ -204,6 +211,8 @@ fn foo2(arg: anytype) bool {
204	211	}
205	212
206	213	test "generic struct" {
	214	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	215
207	216	var a1 = GenNode(i32){
208	217	.value = 13,
209	218	.next = null,
...	...	@@ -243,6 +252,7 @@ test "generic function instantiation turns into comptime call" {
243	252	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
244	253	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
245	254	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	255	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
246	256
247	257	const S = struct {
248	258	fn doTheTest() !void {
...	...	@@ -276,6 +286,8 @@ test "generic function instantiation turns into comptime call" {
276	286	}
277	287
278	288	test "generic function with void and comptime parameter" {
	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	290
279	291	const S = struct { x: i32 };
280	292	const namespace = struct {
281	293	fn foo(v: void, s: *S, comptime T: type) !void {
...	...	@@ -290,6 +302,7 @@ test "generic function with void and comptime parameter" {
290	302
291	303	test "anonymous struct return type referencing comptime parameter" {
292	304	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
293	306
294	307	const S = struct {
295	308	pub fn extraData(comptime T: type, index: usize) struct { data: T, end: usize } {
...	...	@@ -307,6 +320,7 @@ test "anonymous struct return type referencing comptime parameter" {
307	320	test "generic function instantiation non-duplicates" {
308	321	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
309	322	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	323	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
310	324	if (builtin.os.tag == .wasi) return error.SkipZigTest;
311	325
312	326	const S = struct {
...	...	@@ -369,6 +383,8 @@ test "extern function used as generic parameter" {
369	383	}
370	384
371	385	test "generic struct as parameter type" {
	386	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	387
372	388	const S = struct {
373	389	fn doTheTest(comptime Int: type, thing: struct { int: Int }) !void {
374	390	try expect(thing.int == 123);

test/behavior/if.zig+5

...	...	@@ -45,6 +45,7 @@ var global_with_err: anyerror!u32 = error.SomeError;
45	45
46	46	test "unwrap mutable global var" {
47	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
48	49
49	50	if (global_with_val) \|v\| {
50	51	try expect(v == 0);
...	...	@@ -81,6 +82,7 @@ test "if copies its payload" {
81	82	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
82	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
83	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84	86
85	87	const S = struct {
86	88	fn doTheTest() !void {
...	...	@@ -116,6 +118,7 @@ test "if peer expressions inferred optional type" {
116	118	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
117	119	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
118	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	121	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
119	122
120	123	var self: []const u8 = "abcdef";
121	124	var index: usize = 0;
...	...	@@ -133,6 +136,7 @@ test "if-else expression with runtime condition result location is inferred opti
133	136	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
134	137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
135	138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
136	140
137	141	const A = struct { b: u64, c: u64 };
138	142	var d: bool = true;
...	...	@@ -145,6 +149,7 @@ test "result location with inferred type ends up being pointer to comptime_int"
145	149	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
146	150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
147	151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
148	153
149	154	var a: ?u32 = 1234;
150	155	var b: u32 = 2000;

test/behavior/incomplete_struct_param_tld.zig+2

...	...	@@ -22,6 +22,8 @@ fn foo(a: A) i32 {
22	22	}
23	23
24	24	test "incomplete struct param top level declaration" {
	25	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	26
25	27	const a = A{
26	28	.b = B{
27	29	.c = C{ .x = 13 },

test/behavior/inline_switch.zig+9

...	...	@@ -4,6 +4,7 @@ const builtin = @import("builtin");
4	4
5	5	test "inline scalar prongs" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	8
8	9	var x: usize = 0;
9	10	switch (x) {
...	...	@@ -18,6 +19,7 @@ test "inline scalar prongs" {
18	19
19	20	test "inline prong ranges" {
20	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	22	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21	23
22	24	var x: usize = 0;
23	25	switch (x) {
...	...	@@ -31,6 +33,7 @@ test "inline prong ranges" {
31	33	const E = enum { a, b, c, d };
32	34	test "inline switch enums" {
33	35	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	36	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
34	37
35	38	var x: E = .a;
36	39	switch (x) {
...	...	@@ -44,6 +47,7 @@ test "inline switch unions" {
44	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
45	48	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
46	49	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
47	51
48	52	var x: U = .a;
49	53	switch (x) {
...	...	@@ -68,6 +72,7 @@ test "inline switch unions" {
68	72
69	73	test "inline else bool" {
70	74	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	76
72	77	var a = true;
73	78	switch (a) {
...	...	@@ -78,6 +83,7 @@ test "inline else bool" {
78	83
79	84	test "inline else error" {
80	85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
81	87
82	88	const Err = error{ a, b, c };
83	89	var a = Err.a;
...	...	@@ -90,6 +96,7 @@ test "inline else error" {
90	96	test "inline else enum" {
91	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
92	98	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	99	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
93	100
94	101	const E2 = enum(u8) { a = 2, b = 3, c = 4, d = 5 };
95	102	var a: E2 = .a;
...	...	@@ -101,6 +108,7 @@ test "inline else enum" {
101	108
102	109	test "inline else int with gaps" {
103	110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	111	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
104	112
105	113	var a: u8 = 0;
106	114	switch (a) {
...	...	@@ -117,6 +125,7 @@ test "inline else int with gaps" {
117	125
118	126	test "inline else int all values" {
119	127	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	128	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120	129
121	130	var a: u2 = 0;
122	131	switch (a) {

test/behavior/int128.zig+4

...	...	@@ -8,6 +8,7 @@ test "uint128" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	var buff: u128 = maxInt(u128);
13	14	try expect(buff == maxInt(u128));
...	...	@@ -26,6 +27,7 @@ test "undefined 128 bit int" {
26	27	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
27	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
28	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	30	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29	31
30	32	@setRuntimeSafety(true);
31	33
...	...	@@ -43,6 +45,7 @@ test "int128" {
43	45	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
44	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
45	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
46	49
47	50	var buff: i128 = -1;
48	51	try expect(buff < 0 and (buff + 1) == 0);
...	...	@@ -64,6 +67,7 @@ test "truncate int128" {
64	67	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
65	68	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67	71
68	72	var buff: u128 = maxInt(u128);
69	73	try expect(@truncate(u64, buff) == maxInt(u64));

test/behavior/int_div.zig+1

...	...	@@ -6,6 +6,7 @@ test "integer division" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
8	8	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	try testDivision();
11	12	comptime try testDivision();

test/behavior/inttoptr.zig+1

...	...	@@ -14,6 +14,7 @@ test "mutate through ptr initialized with constant intToPtr value" {
14	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18
18	19	forceCompilerAnalyzeBranchHardCodedPtrDereference(false);
19	20	}

test/behavior/ir_block_deps.zig+1

...	...	@@ -20,6 +20,7 @@ fn getErrInt() anyerror!i32 {
20	20	test "ir block deps" {
21	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	24
24	25	try expect((foo(1) catch unreachable) == 0);
25	26	try expect((foo(2) catch unreachable) == 0);

test/behavior/math.zig+43

...	...	@@ -11,6 +11,7 @@ const math = std.math;
11	11	test "assignment operators" {
12	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
13	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	14	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
14	15
15	16	var i: u32 = 0;
16	17	i += 5;
...	...	@@ -63,6 +64,7 @@ test "@clz" {
63	64	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
64	65	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
65	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
66	68
67	69	try testClz();
68	70	comptime try testClz();
...	...	@@ -79,6 +81,7 @@ test "@clz big ints" {
79	81	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
80	82	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
81	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	84	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
82	85
83	86	try testClzBigInts();
84	87	comptime try testClzBigInts();
...	...	@@ -99,6 +102,7 @@ test "@clz vectors" {
99	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
100	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
101	104	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
102	106
103	107	try testClzVectors();
104	108	comptime try testClzVectors();
...	...	@@ -138,6 +142,7 @@ test "@ctz" {
138	142	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
139	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
140	144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
141	146
142	147	try testCtz();
143	148	comptime try testCtz();
...	...	@@ -160,6 +165,7 @@ test "@ctz vectors" {
160	165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
161	166	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	167	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	168	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	169
164	170	try testCtzVectors();
165	171	comptime try testCtzVectors();
...	...	@@ -193,6 +199,7 @@ const ten = 10;
193	199	test "float equality" {
194	200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
195	201	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
196	203
197	204	const x: f64 = 0.012;
198	205	const y: f64 = x + 1.0;
...	...	@@ -370,6 +377,7 @@ test "division" {
370	377	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
371	378	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
372	379	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	380	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
373	381
374	382	try testDivision();
375	383	comptime try testDivision();
...	...	@@ -446,6 +454,7 @@ test "division half-precision floats" {
446	454	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
447	455	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
448	456	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	457	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
449	458
450	459	try testDivisionFP16();
451	460	comptime try testDivisionFP16();
...	...	@@ -526,6 +535,7 @@ fn testUnsignedNegationWrappingEval(x: u16) !void {
526	535	test "unsigned 64-bit division" {
527	536	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
528	537	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
529	539
530	540	try test_u64_div();
531	541	comptime try test_u64_div();
...	...	@@ -566,6 +576,7 @@ test "f128" {
566	576	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
567	577	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
568	578	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	579	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
569	580
570	581	try test_f128();
571	582	comptime try test_f128();
...	...	@@ -594,6 +605,7 @@ test "128-bit multiplication" {
594	605	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
595	606	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
596	607	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	608	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
597	609
598	610	var a: i128 = 3;
599	611	var b: i128 = 2;
...	...	@@ -602,6 +614,8 @@ test "128-bit multiplication" {
602	614	}
603	615
604	616	test "@addWithOverflow" {
	617	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	618
605	619	{
606	620	var result: u8 = undefined;
607	621	try expect(@addWithOverflow(u8, 250, 100, &result));
...	...	@@ -636,6 +650,8 @@ test "@addWithOverflow" {
636	650	}
637	651
638	652	test "small int addition" {
	653	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	654
639	655	var x: u2 = 0;
640	656	try expect(x == 0);
641	657
...	...	@@ -824,6 +840,7 @@ test "extensive @mulWithOverflow" {
824	840	test "@mulWithOverflow bitsize > 32" {
825	841	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
826	842	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	843	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
827	844
828	845	{
829	846	var a: u62 = 3;
...	...	@@ -875,6 +892,8 @@ test "@mulWithOverflow bitsize > 32" {
875	892	}
876	893
877	894	test "@subWithOverflow" {
	895	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	896
878	897	{
879	898	var result: u8 = undefined;
880	899	try expect(@subWithOverflow(u8, 1, 2, &result));
...	...	@@ -981,6 +1000,7 @@ test "quad hex float literal parsing accurate" {
981	1000	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
982	1001	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
983	1002	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1003	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
984	1004
985	1005	const a: f128 = 0x1.1111222233334444555566667777p+0;
986	1006
...	...	@@ -1204,6 +1224,7 @@ test "float modulo division using @mod" {
1204	1224	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1205	1225	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1206	1226	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1227	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1207	1228	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
1208	1229
1209	1230	comptime try fmod(f16);
...	...	@@ -1246,6 +1267,7 @@ test "@sqrt" {
1246	1267	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1247	1268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1248	1269	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1249	1271
1250	1272	try testSqrt(f64, 12.0);
1251	1273	comptime try testSqrt(f64, 12.0);
...	...	@@ -1272,6 +1294,7 @@ test "@fabs" {
1272	1294	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1273	1295	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1274	1296	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1297	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1275	1298
1276	1299	try testFabs(f128, 12.0);
1277	1300	comptime try testFabs(f128, 12.0);
...	...	@@ -1293,6 +1316,7 @@ test "@fabs f80" {
1293	1316	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1294	1317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1295	1318	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1319	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1296	1320
1297	1321	try testFabs(f80, 12.0);
1298	1322	comptime try testFabs(f80, 12.0);
...	...	@@ -1309,6 +1333,7 @@ test "@floor" {
1309	1333	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1310	1334	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1311	1335	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1336	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1312	1337
1313	1338	try testFloor(f64, 12.0);
1314	1339	comptime try testFloor(f64, 12.0);
...	...	@@ -1328,6 +1353,7 @@ test "@floor f80" {
1328	1353	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1329	1354	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1330	1355	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1356	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1331	1357	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
1332	1358
1333	1359	try testFloor(f80, 12.0);
...	...	@@ -1339,6 +1365,7 @@ test "@floor f128" {
1339	1365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1340	1366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1341	1367	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1368	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1342	1369
1343	1370	try testFloor(f128, 12.0);
1344	1371	comptime try testFloor(f128, 12.0);
...	...	@@ -1355,6 +1382,7 @@ test "@ceil" {
1355	1382	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1356	1383	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1357	1384	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1385	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1358	1386
1359	1387	try testCeil(f64, 12.0);
1360	1388	comptime try testCeil(f64, 12.0);
...	...	@@ -1374,6 +1402,7 @@ test "@ceil f80" {
1374	1402	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1375	1403	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1376	1404	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1405	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1377	1406	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
1378	1407
1379	1408	try testCeil(f80, 12.0);
...	...	@@ -1385,6 +1414,7 @@ test "@ceil f128" {
1385	1414	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1386	1415	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1387	1416	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1417	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1388	1418
1389	1419	try testCeil(f128, 12.0);
1390	1420	comptime try testCeil(f128, 12.0);
...	...	@@ -1401,6 +1431,7 @@ test "@trunc" {
1401	1431	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1402	1432	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1403	1433	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1434	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1404	1435
1405	1436	try testTrunc(f64, 12.0);
1406	1437	comptime try testTrunc(f64, 12.0);
...	...	@@ -1420,6 +1451,7 @@ test "@trunc f80" {
1420	1451	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1421	1452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1422	1453	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1454	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1423	1455	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
1424	1456
1425	1457	try testTrunc(f80, 12.0);
...	...	@@ -1437,6 +1469,7 @@ test "@trunc f128" {
1437	1469	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1438	1470	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1439	1471	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1472	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1440	1473
1441	1474	try testTrunc(f128, 12.0);
1442	1475	comptime try testTrunc(f128, 12.0);
...	...	@@ -1461,6 +1494,7 @@ test "@round" {
1461	1494	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1462	1495	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1463	1496	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1497	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1464	1498
1465	1499	try testRound(f64, 12.0);
1466	1500	comptime try testRound(f64, 12.0);
...	...	@@ -1480,6 +1514,7 @@ test "@round f80" {
1480	1514	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1481	1515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1482	1516	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1517	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1483	1518	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
1484	1519
1485	1520	try testRound(f80, 12.0);
...	...	@@ -1491,6 +1526,7 @@ test "@round f128" {
1491	1526	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1492	1527	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1493	1528	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1529	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1494	1530
1495	1531	try testRound(f128, 12.0);
1496	1532	comptime try testRound(f128, 12.0);
...	...	@@ -1508,6 +1544,7 @@ test "vector integer addition" {
1508	1544	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1509	1545	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1510	1546	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	1547	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1511	1548
1512	1549	const S = struct {
1513	1550	fn doTheTest() !void {
...	...	@@ -1528,6 +1565,7 @@ test "NaN comparison" {
1528	1565	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1529	1566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1530	1567	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1568	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1531	1569
1532	1570	try testNanEqNan(f16);
1533	1571	try testNanEqNan(f32);
...	...	@@ -1544,6 +1582,7 @@ test "NaN comparison f80" {
1544	1582	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1545	1583	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1546	1584	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1585	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1547	1586
1548	1587	try testNanEqNan(f80);
1549	1588	comptime try testNanEqNan(f80);
...	...	@@ -1566,6 +1605,7 @@ test "vector comparison" {
1566	1605	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1567	1606	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1568	1607	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1608	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1569	1609
1570	1610	const S = struct {
1571	1611	fn doTheTest() !void {
...	...	@@ -1595,6 +1635,7 @@ test "signed zeros are represented properly" {
1595	1635	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1596	1636	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1597	1637	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1638	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1598	1639
1599	1640	const S = struct {
1600	1641	fn doTheTest() !void {
...	...	@@ -1631,6 +1672,7 @@ test "fabs" {
1631	1672	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1632	1673	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1633	1674	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1675	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1634	1676
1635	1677	inline for ([_]type{ f16, f32, f64, f80, f128, c_longdouble }) \|T\| {
1636	1678	// normals
...	...	@@ -1659,6 +1701,7 @@ test "absFloat" {
1659	1701	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1660	1702	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1661	1703	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1704	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1662	1705
1663	1706	try testAbsFloat();
1664	1707	comptime try testAbsFloat();

test/behavior/maximum_minimum.zig+4

...	...	@@ -8,6 +8,7 @@ test "@max" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	const S = struct {
13	14	fn doTheTest() !void {
...	...	@@ -27,6 +28,7 @@ test "@max on vectors" {
27	28	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
28	29	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
30	32
31	33	const S = struct {
32	34	fn doTheTest() !void {
...	...	@@ -54,6 +56,7 @@ test "@min" {
54	56	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
55	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56	58	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	59	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57	60
58	61	const S = struct {
59	62	fn doTheTest() !void {
...	...	@@ -73,6 +76,7 @@ test "@min for vectors" {
73	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75	78	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
76	80
77	81	const S = struct {
78	82	fn doTheTest() !void {

test/behavior/member_func.zig+2

...	...	@@ -30,6 +30,7 @@ test "standard field calls" {
30	30	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
31	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33	34
34	35	try expect(HasFuncs.one(0) == 1);
35	36	try expect(HasFuncs.two(0) == 2);
...	...	@@ -73,6 +74,7 @@ test "@field field calls" {
73	74	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
74	75	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
75	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
76	78
77	79	try expect(@field(HasFuncs, "one")(0) == 1);
78	80	try expect(@field(HasFuncs, "two")(0) == 2);

test/behavior/merge_error_sets.zig+2

...	...	@@ -14,6 +14,8 @@ fn foo() C!void {
14	14	test "merge error sets" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	18
17	19	if (foo()) {
18	20	@panic("unexpected");
19	21	} else \|err\| switch (err) {

test/behavior/muladd.zig+9

...	...	@@ -5,6 +5,7 @@ test "@mulAdd" {
5	5	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
6	6	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	comptime try testMulAdd();
10	11	try testMulAdd();
...	...	@@ -30,6 +31,7 @@ test "@mulAdd f16" {
30	31	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
31	32	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
32	33	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	34	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
33	35
34	36	comptime try testMulAdd16();
35	37	try testMulAdd16();
...	...	@@ -47,6 +49,7 @@ test "@mulAdd f80" {
47	49	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
48	50	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
49	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
50	53	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
51	54
52	55	comptime try testMulAdd80();
...	...	@@ -65,6 +68,7 @@ test "@mulAdd f128" {
65	68	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
66	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	71	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68	72
69	73	comptime try testMulAdd128();
70	74	try testMulAdd128();
...	...	@@ -95,6 +99,7 @@ test "vector f16" {
95	99	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
96	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
97	101	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
98	103
99	104	comptime try vector16();
100	105	try vector16();
...	...	@@ -118,6 +123,7 @@ test "vector f32" {
118	123	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
119	124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
120	125	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
121	127
122	128	comptime try vector32();
123	129	try vector32();
...	...	@@ -141,6 +147,7 @@ test "vector f64" {
141	147	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
142	148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
143	149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
144	151
145	152	comptime try vector64();
146	153	try vector64();
...	...	@@ -163,6 +170,7 @@ test "vector f80" {
163	170	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
164	171	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
165	172	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
166	174	if (builtin.zig_backend == .stage2_llvm and builtin.os.tag == .windows) return error.SkipZigTest; // https://github.com/ziglang/zig/issues/12602
167	175
168	176	comptime try vector80();
...	...	@@ -187,6 +195,7 @@ test "vector f128" {
187	195	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
188	196	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
189	197	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	198	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
190	199
191	200	comptime try vector128();
192	201	try vector128();

test/behavior/null.zig+8

...	...	@@ -32,6 +32,7 @@ test "test maybe object and get a pointer to the inner value" {
32	32	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
33	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
34	34	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	35	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
35	36
36	37	var maybe_bool: ?bool = true;
37	38
...	...	@@ -52,6 +53,7 @@ test "maybe return" {
52	53	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
53	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
54	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
55	57
56	58	try maybeReturnImpl();
57	59	comptime try maybeReturnImpl();
...	...	@@ -72,6 +74,7 @@ test "test null runtime" {
72	74	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
73	75	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
74	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	77	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
75	78
76	79	try testTestNullRuntime(null);
77	80	}
...	...	@@ -83,6 +86,7 @@ fn testTestNullRuntime(x: ?i32) !void {
83	86	test "optional void" {
84	87	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
85	88	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	89	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
86	90
87	91	try optionalVoidImpl();
88	92	comptime try optionalVoidImpl();
...	...	@@ -106,6 +110,7 @@ const Empty = struct {};
106	110	test "optional struct{}" {
107	111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
108	112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
109	114
110	115	_ = try optionalEmptyStructImpl();
111	116	_ = comptime try optionalEmptyStructImpl();
...	...	@@ -131,6 +136,7 @@ test "null with default unwrap" {
131	136
132	137	test "optional pointer to 0 bit type null value at runtime" {
133	138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	139	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
134	140
135	141	const EmptyStruct = struct {};
136	142	var x: ?*EmptyStruct = null;
...	...	@@ -141,6 +147,7 @@ test "if var maybe pointer" {
141	147	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
142	148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
143	149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
144	151
145	152	try expect(shouldBeAPlus1(Particle{
146	153	.a = 14,
...	...	@@ -184,6 +191,7 @@ test "unwrap optional which is field of global var" {
184	191	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
185	192	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
186	193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	194	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
187	195
188	196	struct_with_optional.field = null;
189	197	if (struct_with_optional.field) \|payload\| {

test/behavior/optional.zig+22

...	...	@@ -7,6 +7,7 @@ const expectEqualStrings = std.testing.expectEqualStrings;
7	7
8	8	test "passing an optional integer as a parameter" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	const S = struct {
12	13	fn entry() bool {
...	...	@@ -25,6 +26,8 @@ test "passing an optional integer as a parameter" {
25	26	pub const EmptyStruct = struct {};
26	27
27	28	test "optional pointer to size zero struct" {
	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	30
28	31	var e = EmptyStruct{};
29	32	var o: ?*EmptyStruct = &e;
30	33	try expect(o != null);
...	...	@@ -54,6 +57,7 @@ fn testNullPtrsEql() !void {
54	57	test "optional with void type" {
55	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
56	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	60	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
57	61
58	62	const Foo = struct {
59	63	x: ?void,
...	...	@@ -66,6 +70,7 @@ test "address of unwrap optional" {
66	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
67	71	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
68	72	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	73	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
69	74
70	75	const S = struct {
71	76	const Foo = struct {
...	...	@@ -87,6 +92,7 @@ test "nested optional field in struct" {
87	92	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
88	93	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
89	94	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	95	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
90	96
91	97	const S2 = struct {
92	98	y: u8,
...	...	@@ -104,6 +110,7 @@ test "equality compare optional with non-optional" {
104	110	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	111	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
106	112	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	113	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
107	114
108	115	try test_cmp_optional_non_optional();
109	116	comptime try test_cmp_optional_non_optional();
...	...	@@ -140,6 +147,7 @@ fn test_cmp_optional_non_optional() !void {
140	147
141	148	test "unwrap function call with optional pointer return value" {
142	149	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
143	151
144	152	const S = struct {
145	153	fn entry() !void {
...	...	@@ -160,6 +168,7 @@ test "unwrap function call with optional pointer return value" {
160	168
161	169	test "nested orelse" {
162	170	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	172
164	173	const S = struct {
165	174	fn entry() !void {
...	...	@@ -185,6 +194,7 @@ test "nested orelse" {
185	194
186	195	test "self-referential struct through a slice of optional" {
187	196	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	197	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
188	198
189	199	const S = struct {
190	200	const Node = struct {
...	...	@@ -220,6 +230,7 @@ test "coerce an anon struct literal to optional struct" {
220	230	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
221	231	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
222	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	233	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
223	234
224	235	const S = struct {
225	236	const Struct = struct {
...	...	@@ -239,6 +250,7 @@ test "0-bit child type coerced to optional return ptr result location" {
239	250	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
240	251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
241	252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	253	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
242	254
243	255	const S = struct {
244	256	fn doTheTest() !void {
...	...	@@ -263,6 +275,7 @@ test "0-bit child type coerced to optional return ptr result location" {
263	275
264	276	test "0-bit child type coerced to optional" {
265	277	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
266	279
267	280	const S = struct {
268	281	fn doTheTest() !void {
...	...	@@ -290,6 +303,7 @@ test "array of optional unaligned types" {
290	303	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
291	304	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
292	305	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	306	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
293	307
294	308	const Enum = enum { one, two, three };
295	309
...	...	@@ -326,6 +340,7 @@ test "optional pointer to zero bit optional payload" {
326	340	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
327	341	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
328	342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
329	344
330	345	const B = struct {
331	346	fn foo(_: *@This()) void {}
...	...	@@ -345,6 +360,7 @@ test "optional pointer to zero bit error union payload" {
345	360	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
346	361	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
347	362	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	363	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
348	364
349	365	const B = struct {
350	366	fn foo(_: *@This()) void {}
...	...	@@ -377,6 +393,8 @@ const NoReturn = struct {
377	393	};
378	394
379	395	test "optional of noreturn used with if" {
	396	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	397
380	398	NoReturn.a = 64;
381	399	if (NoReturn.loop()) \|_\| {
382	400	@compileError("bad");
...	...	@@ -386,6 +404,8 @@ test "optional of noreturn used with if" {
386	404	}
387	405
388	406	test "optional of noreturn used with orelse" {
	407	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	408
389	409	NoReturn.a = 64;
390	410	const val = NoReturn.testOrelse();
391	411	try expect(val == 123);
...	...	@@ -402,6 +422,7 @@ test "alignment of wrapping an optional payload" {
402	422	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
403	423	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
404	424	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	425	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
405	426
406	427	const S = struct {
407	428	const I = extern struct { x: i128 };
...	...	@@ -419,6 +440,7 @@ test "Optional slice size is optimized" {
419	440	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
420	441	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
421	442	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
	443	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
422	444
423	445	try expect(@sizeOf(?[]u8) == @sizeOf([]u8));
424	446	var a: ?[]const u8 = null;

test/behavior/packed-struct.zig+10

...	...	@@ -6,6 +6,8 @@ const expectEqual = std.testing.expectEqual;
6	6	const native_endian = builtin.cpu.arch.endian();
7	7
8	8	test "flags in packed structs" {
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	10
9	11	const Flags1 = packed struct {
10	12	// first 8 bits
11	13	b0_0: u1,
...	...	@@ -90,6 +92,8 @@ test "flags in packed structs" {
90	92	}
91	93
92	94	test "consistent size of packed structs" {
	95	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	96
93	97	const TxData1 = packed struct { data: u8, _23: u23, full: bool = false };
94	98	const TxData2 = packed struct { data: u9, _22: u22, full: bool = false };
95	99
...	...	@@ -354,6 +358,7 @@ test "load pointer from packed struct" {
354	358	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
355	359	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
356	360	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	361	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
357	362
358	363	const A = struct {
359	364	index: u16,
...	...	@@ -374,6 +379,7 @@ test "@ptrToInt on a packed struct field" {
374	379	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
375	380	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
376	381	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	382	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
377	383
378	384	const S = struct {
379	385	const P = packed struct {
...	...	@@ -394,6 +400,7 @@ test "optional pointer in packed struct" {
394	400	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
395	401	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
396	402	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	403	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
397	404
398	405	const T = packed struct { ptr: ?*const u8 };
399	406	var n: u8 = 0;
...	...	@@ -407,6 +414,7 @@ test "nested packed struct field access test" {
407	414	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
408	415	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
409	416	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	417	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
410	418	//
411	419	const Vec2 = packed struct {
412	420	x: f32,
...	...	@@ -523,6 +531,7 @@ test "runtime init of unnamed packed struct type" {
523	531	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
524	532	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
525	533	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	534	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
526	535
527	536	var z: u8 = 123;
528	537	try (packed struct {
...	...	@@ -537,6 +546,7 @@ test "packed struct passed to callconv(.C) function" {
537	546	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
538	547	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
539	548	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	549	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
540	550
541	551	const S = struct {
542	552	const Packed = packed struct {

test/behavior/packed_struct_explicit_backing_int.zig+1

...	...	@@ -9,6 +9,7 @@ test "packed struct explicit backing integer" {
9	9	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	const S1 = packed struct { a: u8, b: u8, c: u8 };
14	15

test/behavior/pointers.zig+21

...	...	@@ -18,6 +18,7 @@ fn testDerefPtr() !void {
18	18
19	19	test "pointer arithmetic" {
20	20	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
21	22
22	23	var ptr: [*]const u8 = "abcd";
23	24
...	...	@@ -49,6 +50,8 @@ fn PtrOf(comptime T: type) type {
49	50	}
50	51
51	52	test "implicit cast single item pointer to C pointer and back" {
	53	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	54
52	55	var y: u8 = 11;
53	56	var x: [*c]u8 = &y;
54	57	var z: *u8 = x;
...	...	@@ -64,6 +67,7 @@ test "initialize const optional C pointer to null" {
64	67
65	68	test "assigning integer to C pointer" {
66	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67	71
68	72	var x: i32 = 0;
69	73	var y: i32 = 1;
...	...	@@ -79,6 +83,8 @@ test "assigning integer to C pointer" {
79	83	}
80	84
81	85	test "C pointer comparison and arithmetic" {
	86	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	87
82	88	const S = struct {
83	89	fn doTheTest() !void {
84	90	var ptr1: [*c]u32 = 0;
...	...	@@ -143,6 +149,7 @@ test "peer type resolution with C pointer and const pointer" {
143	149	test "implicit casting between C pointer and optional non-C pointer" {
144	150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
145	151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
146	153
147	154	var slice: []const u8 = "aoeu";
148	155	const opt_many_ptr: ?[*]const u8 = slice.ptr;
...	...	@@ -157,6 +164,7 @@ test "implicit cast error unions with non-optional to optional pointer" {
157	164	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
158	165	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
159	166	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	167	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
160	168
161	169	const S = struct {
162	170	fn doTheTest() !void {
...	...	@@ -186,6 +194,7 @@ test "allowzero pointer and slice" {
186	194	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
187	195	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
188	196	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	197	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
189	198
190	199	var ptr = @intToPtr([*]allowzero i32, 0);
191	200	var opt_ptr: ?[*]allowzero i32 = ptr;
...	...	@@ -204,6 +213,7 @@ test "assign null directly to C pointer and test null equality" {
204	213	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
205	214	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206	215	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	216	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
207	217
208	218	var x: [*c]i32 = null;
209	219	try expect(x == null);
...	...	@@ -269,6 +279,7 @@ test "array initialization types" {
269	279
270	280	test "null terminated pointer" {
271	281	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	282	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
272	283
273	284	const S = struct {
274	285	fn doTheTest() !void {
...	...	@@ -285,6 +296,7 @@ test "null terminated pointer" {
285	296
286	297	test "allow any sentinel" {
287	298	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	299	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
288	300
289	301	const S = struct {
290	302	fn doTheTest() !void {
...	...	@@ -299,6 +311,7 @@ test "allow any sentinel" {
299	311
300	312	test "pointer sentinel with enums" {
301	313	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	314	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
302	315
303	316	const S = struct {
304	317	const Number = enum {
...	...	@@ -319,6 +332,7 @@ test "pointer sentinel with enums" {
319	332	test "pointer sentinel with optional element" {
320	333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
321	334	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	335	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
322	336
323	337	const S = struct {
324	338	fn doTheTest() !void {
...	...	@@ -335,6 +349,7 @@ test "pointer sentinel with +inf" {
335	349	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
336	350	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
337	351	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	352	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
338	353
339	354	const S = struct {
340	355	fn doTheTest() !void {
...	...	@@ -401,6 +416,7 @@ test "indexing array with sentinel returns correct type" {
401	416	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
402	417	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
403	418	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	419	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
404	420
405	421	var s: [:0]const u8 = "abc";
406	422	try testing.expectEqualSlices(u8, "*const u8", @typeName(@TypeOf(&s[0])));
...	...	@@ -408,6 +424,7 @@ test "indexing array with sentinel returns correct type" {
408	424
409	425	test "element pointer to slice" {
410	426	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	427	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
411	428
412	429	const S = struct {
413	430	fn doTheTest() !void {
...	...	@@ -429,6 +446,7 @@ test "element pointer to slice" {
429	446
430	447	test "element pointer arithmetic to slice" {
431	448	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	449	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
432	450
433	451	const S = struct {
434	452	fn doTheTest() !void {
...	...	@@ -452,6 +470,8 @@ test "element pointer arithmetic to slice" {
452	470	}
453	471
454	472	test "array slicing to slice" {
	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	474
455	475	const S = struct {
456	476	fn doTheTest() !void {
457	477	var str: [5]i32 = [_]i32{ 1, 2, 3, 4, 5 };
...	...	@@ -481,6 +501,7 @@ test "ptrCast comptime known slice to C pointer" {
481	501	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
482	502	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
483	503	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	504	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
484	505
485	506	const s: [:0]const u8 = "foo";
486	507	var p = @ptrCast([*c]const u8, s);

test/behavior/popcount.zig+3

...	...	@@ -7,6 +7,7 @@ test "@popCount integers" {
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	10	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
10	11
11	12	comptime try testPopCountIntegers();
12	13	try testPopCountIntegers();
...	...	@@ -16,6 +17,7 @@ test "@popCount 128bit integer" {
16	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
17	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
18	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	21
20	22	comptime {
21	23	try expect(@popCount(@as(u128, 0b11111111000110001100010000100001000011000011100101010001)) == 24);
...	...	@@ -70,6 +72,7 @@ test "@popCount vectors" {
70	72	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
71	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
72	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73	76
74	77	comptime try testPopCountVectors();
75	78	try testPopCountVectors();

test/behavior/ptrcast.zig+8

...	...	@@ -23,6 +23,7 @@ test "reinterpret an array over multiple elements, with no well-defined layout"
23	23	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	26	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
26	27
27	28	try testReinterpretWithOffsetAndNoWellDefinedLayout();
28	29	comptime try testReinterpretWithOffsetAndNoWellDefinedLayout();
...	...	@@ -38,6 +39,7 @@ fn testReinterpretWithOffsetAndNoWellDefinedLayout() !void {
38	39
39	40	test "reinterpret bytes inside auto-layout struct as integer with nonzero offset" {
40	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	42	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	43
42	44	try testReinterpretStructWrappedBytesAsInteger();
43	45	comptime try testReinterpretStructWrappedBytesAsInteger();
...	...	@@ -56,6 +58,7 @@ fn testReinterpretStructWrappedBytesAsInteger() !void {
56	58	test "reinterpret bytes of an array into an extern struct" {
57	59	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
58	60	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	61	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59	62
60	63	try testReinterpretBytesAsExternStruct();
61	64	comptime try testReinterpretBytesAsExternStruct();
...	...	@@ -126,6 +129,7 @@ test "lower reinterpreted comptime field ptr (with under-aligned fields)" {
126	129	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
127	130	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
128	131	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	132	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
129	133
130	134	// Test lowering a field ptr
131	135	comptime var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
...	...	@@ -149,6 +153,7 @@ test "lower reinterpreted comptime field ptr" {
149	153	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
150	154	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
151	155	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
152	157
153	158	// Test lowering a field ptr
154	159	comptime var bytes align(4) = [_]u8{ 1, 2, 3, 4, 5, 6, 7, 8 };
...	...	@@ -169,6 +174,7 @@ test "lower reinterpreted comptime field ptr" {
169	174
170	175	test "reinterpret struct field at comptime" {
171	176	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	177	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
172	178
173	179	const numNative = comptime Bytes.init(0x12345678);
174	180	if (native_endian != .Little) {
...	...	@@ -200,6 +206,7 @@ test "comptime ptrcast keeps larger alignment" {
200	206	test "implicit optional pointer to optional anyopaque pointer" {
201	207	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
202	208	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
203	210
204	211	var buf: [4]u8 = "aoeu".*;
205	212	var x: ?[*]u8 = &buf;
...	...	@@ -211,6 +218,7 @@ test "implicit optional pointer to optional anyopaque pointer" {
211	218	test "@ptrCast slice to slice" {
212	219	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
213	220	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
214	222
215	223	const S = struct {
216	224	fn foo(slice: []u32) []i32 {

test/behavior/ref_var_in_if_after_if_2nd_switch_prong.zig+1

...	...	@@ -8,6 +8,7 @@ test "reference a variable in an if after an if in the 2nd switch prong" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	try foo(true, Num.Two, false, "aoeu");
13	14	try expect(!ok);

test/behavior/reflection.zig+1

...	...	@@ -28,6 +28,7 @@ fn dummy(a: bool, b: i32, c: f32) i32 {
28	28	test "reflection: @field" {
29	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	30	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31	32
32	33	var f = Foo{
33	34	.one = 42,

test/behavior/saturating_arithmetic.zig+8

...	...	@@ -8,6 +8,7 @@ test "saturating add" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	const S = struct {
13	14	fn doTheTest() !void {
...	...	@@ -54,6 +55,8 @@ test "saturating add 128bit" {
54	55	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
55	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
56	57	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	59
57	60	const S = struct {
58	61	fn doTheTest() !void {
59	62	try testSatAdd(i128, maxInt(i128), -maxInt(i128), 0);
...	...	@@ -77,6 +80,7 @@ test "saturating subtraction" {
77	80	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
78	81	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
79	82	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80	84
81	85	const S = struct {
82	86	fn doTheTest() !void {
...	...	@@ -122,6 +126,7 @@ test "saturating subtraction 128bit" {
122	126	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
123	127	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
124	128	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	129	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
125	130
126	131	const S = struct {
127	132	fn doTheTest() !void {
...	...	@@ -148,6 +153,7 @@ test "saturating multiplication" {
148	153	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
149	154	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
150	155	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	156	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
151	157
152	158	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) {
153	159	// https://github.com/ziglang/zig/issues/9660
...	...	@@ -191,6 +197,7 @@ test "saturating shift-left" {
191	197	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
192	198	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
193	199	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	200	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194	201
195	202	const S = struct {
196	203	fn doTheTest() !void {
...	...	@@ -229,6 +236,7 @@ test "saturating shl uses the LHS type" {
229	236	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
230	237	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
231	238	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	239	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
232	240
233	241	const lhs_const: u8 = 1;
234	242	var lhs_var: u8 = 1;

test/behavior/select.zig+2

...	...	@@ -9,6 +9,7 @@ test "@select vectors" {
9	9	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	comptime try selectVectors();
14	15	try selectVectors();
...	...	@@ -37,6 +38,7 @@ test "@select arrays" {
37	38	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
38	39	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
39	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
40	42
41	43	comptime try selectArrays();
42	44	try selectArrays();

test/behavior/shuffle.zig+3

...	...	@@ -9,6 +9,7 @@ test "@shuffle int" {
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	const S = struct {
14	15	fn doTheTest() !void {
...	...	@@ -50,6 +51,7 @@ test "@shuffle bool 1" {
50	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
51	52	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
52	53	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	54	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53	55
54	56	const S = struct {
55	57	fn doTheTest() !void {
...	...	@@ -70,6 +72,7 @@ test "@shuffle bool 2" {
70	72	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
71	73	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
72	74	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
73	76
74	77	if (builtin.zig_backend == .stage2_llvm) {
75	78	// https://github.com/ziglang/zig/issues/3246

test/behavior/sizeof_and_typeof.zig+4

...	...	@@ -76,6 +76,7 @@ const P = packed struct {
76	76
77	77	test "@offsetOf" {
78	78	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
79	80
80	81	// Packed structs have fixed memory layout
81	82	try expect(@offsetOf(P, "a") == 0);
...	...	@@ -102,6 +103,8 @@ test "@offsetOf" {
102	103	}
103	104
104	105	test "@bitOffsetOf" {
	106	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	107
105	108	// Packed structs have fixed memory layout
106	109	try expect(@bitOffsetOf(P, "a") == 0);
107	110	try expect(@bitOffsetOf(P, "b") == 8);
...	...	@@ -264,6 +267,7 @@ test "bitSizeOf comptime_int" {
264	267	test "runtime instructions inside typeof in comptime only scope" {
265	268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
266	269	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
267	271
268	272	{
269	273	var y: i8 = 2;

test/behavior/slice.zig+24

...	...	@@ -29,6 +29,7 @@ comptime {
29	29
30	30	test "slicing" {
31	31	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	33
33	34	var array: [20]i32 = undefined;
34	35
...	...	@@ -64,6 +65,7 @@ test "comptime slice of undefined pointer of length 0" {
64	65
65	66	test "implicitly cast array of size 0 to slice" {
66	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
67	69
68	70	var msg = [_]u8{};
69	71	try assertLenIsZero(&msg);
...	...	@@ -74,6 +76,8 @@ fn assertLenIsZero(msg: []const u8) !void {
74	76	}
75	77
76	78	test "access len index of sentinel-terminated slice" {
	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	80
77	81	const S = struct {
78	82	fn doTheTest() !void {
79	83	var slice: [:0]const u8 = "hello";
...	...	@@ -119,6 +123,7 @@ test "slice of type" {
119	123	test "generic malloc free" {
120	124	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
121	125	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	126	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
122	127
123	128	const a = memAlloc(u8, 10) catch unreachable;
124	129	memFree(u8, a);
...	...	@@ -170,6 +175,7 @@ test "comptime pointer cast array and then slice" {
170	175	test "slicing zero length array" {
171	176	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
172	177	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
173	179
174	180	const s1 = ""[0..];
175	181	const s2 = ([_]u32{})[0..];
...	...	@@ -204,6 +210,8 @@ test "slice string literal has correct type" {
204	210	}
205	211
206	212	test "result location zero sized array inside struct field implicit cast to slice" {
	213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	214
207	215	const E = struct {
208	216	entries: []u32,
209	217	};
...	...	@@ -214,6 +222,7 @@ test "result location zero sized array inside struct field implicit cast to slic
214	222	test "runtime safety lets us slice from len..len" {
215	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
216	224	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217	226
218	227	var an_array = [_]u8{ 1, 2, 3 };
219	228	try expect(mem.eql(u8, sliceFromLenToLen(an_array[0..], 3, 3), ""));
...	...	@@ -225,6 +234,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
225	234
226	235	test "C pointer" {
227	236	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	237	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
228	238
229	239	var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
230	240	var len: u32 = 10;
...	...	@@ -236,6 +246,7 @@ test "C pointer slice access" {
236	246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
237	247	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
238	248	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	249	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
239	250
240	251	var buf: [10]u32 = [1]u32{42} ** 10;
241	252	const c_ptr = @ptrCast([*c]const u32, &buf);
...	...	@@ -264,6 +275,7 @@ fn sliceSum(comptime q: []const u8) i32 {
264	275
265	276	test "slice type with custom alignment" {
266	277	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
267	279
268	280	const LazilyResolvedType = struct {
269	281	anything: i32,
...	...	@@ -277,6 +289,7 @@ test "slice type with custom alignment" {
277	289
278	290	test "obtaining a null terminated slice" {
279	291	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	292	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
280	293
281	294	// here we have a normal array
282	295	var buf: [50]u8 = undefined;
...	...	@@ -318,6 +331,7 @@ test "empty array to slice" {
318	331
319	332	test "@ptrCast slice to pointer" {
320	333	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	334	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
321	335
322	336	const S = struct {
323	337	fn doTheTest() !void {
...	...	@@ -336,6 +350,7 @@ test "slice syntax resulting in pointer-to-array" {
336	350	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
337	351	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
338	352	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	353	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
339	354
340	355	const S = struct {
341	356	fn doTheTest() !void {
...	...	@@ -469,6 +484,7 @@ test "slice syntax resulting in pointer-to-array" {
469	484	test "slice pointer-to-array null terminated" {
470	485	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
471	486	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	487	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
472	488
473	489	comptime {
474	490	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
...	...	@@ -487,6 +503,7 @@ test "slice pointer-to-array null terminated" {
487	503
488	504	test "slice pointer-to-array zero length" {
489	505	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	506	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
490	507
491	508	comptime {
492	509	{
...	...	@@ -521,6 +538,7 @@ test "type coercion of pointer to anon struct literal to pointer to slice" {
521	538	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
522	539	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
523	540	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	541	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
524	542
525	543	const S = struct {
526	544	const U = union {
...	...	@@ -573,6 +591,7 @@ test "array mult of slice gives ptr to array" {
573	591
574	592	test "slice bounds in comptime concatenation" {
575	593	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	594	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
576	595
577	596	const bs = comptime blk: {
578	597	const b = "........1........";
...	...	@@ -607,6 +626,7 @@ test "slice sentinel access at comptime" {
607	626
608	627	test "slicing array with sentinel as end index" {
609	628	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	629	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
610	630
611	631	const S = struct {
612	632	fn do() !void {
...	...	@@ -624,6 +644,7 @@ test "slicing array with sentinel as end index" {
624	644
625	645	test "slicing slice with sentinel as end index" {
626	646	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	647	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
627	648
628	649	const S = struct {
629	650	fn do() !void {
...	...	@@ -664,6 +685,8 @@ test "slice field ptr const" {
664	685	}
665	686
666	687	test "slice field ptr var" {
	688	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	689
667	690	var var_slice: []const u8 = "string";
668	691
669	692	var var_ptr_var_slice = &var_slice;
...	...	@@ -679,6 +702,7 @@ test "global slice field access" {
679	702	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
680	703	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
681	704	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	705	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
682	706
683	707	const S = struct {
684	708	var slice: []const u8 = undefined;

test/behavior/src.zig+1

...	...	@@ -16,6 +16,7 @@ const expect = std.testing.expect;
16	16	test "@src" {
17	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
18	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	19	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
19	20	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
20	21
21	22	try doTheTest();

test/behavior/struct.zig+11

...	...	@@ -66,6 +66,8 @@ const SmallStruct = struct {
66	66	};
67	67
68	68	test "lower unnamed constants" {
	69	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	70
69	71	var foo = SmallStruct{ .a = 1, .b = 255 };
70	72	try expect(foo.first() == 1);
71	73	try expect(foo.second() == 255);
...	...	@@ -170,12 +172,16 @@ const MemberFnTestFoo = struct {
170	172	};
171	173
172	174	test "call member function directly" {
	175	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	176
173	177	const instance = MemberFnTestFoo{ .x = 1234 };
174	178	const result = MemberFnTestFoo.member(instance);
175	179	try expect(result == 1234);
176	180	}
177	181
178	182	test "store member function in variable" {
	183	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	184
179	185	const instance = MemberFnTestFoo{ .x = 1234 };
180	186	const memberFn = MemberFnTestFoo.member;
181	187	const result = memberFn(instance);
...	...	@@ -782,6 +788,7 @@ test "packed struct with fp fields" {
782	788	test "fn with C calling convention returns struct by value" {
783	789	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
784	790	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	791	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
785	792
786	793	const S = struct {
787	794	fn entry() !void {
...	...	@@ -807,6 +814,7 @@ test "non-packed struct with u128 entry in union" {
807	814	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
808	815	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
809	816	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	817	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
810	818
811	819	const U = union(enum) {
812	820	Num: u128,
...	...	@@ -853,6 +861,7 @@ test "packed struct field passed to generic function" {
853	861
854	862	test "anonymous struct literal syntax" {
855	863	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	864	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
856	865
857	866	const S = struct {
858	867	const Point = struct {
...	...	@@ -959,6 +968,7 @@ test "tuple element initialized with fn call" {
959	968	test "struct with union field" {
960	969	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
961	970	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	971	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
962	972
963	973	const Value = struct {
964	974	ref: u32 = 2,
...	...	@@ -1331,6 +1341,7 @@ test "under-aligned struct field" {
1331	1341	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1332	1342	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1333	1343	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1344	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1334	1345
1335	1346	const U = extern union {
1336	1347	fd: i32,

test/behavior/struct_contains_null_ptr_itself.zig+2

...	...	@@ -5,6 +5,8 @@ const builtin = @import("builtin");
5	5	test "struct contains null pointer which contains original struct" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7	7	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9
8	10	var x: ?*NodeLineComment = null;
9	11	try expect(x == null);
10	12	}

test/behavior/struct_contains_slice_of_itself.zig+2

...	...	@@ -13,6 +13,7 @@ const NodeAligned = struct {
13	13
14	14	test "struct contains slice of itself" {
15	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	16	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
16	17
17	18	var other_nodes = [_]Node{
18	19	Node{
...	...	@@ -52,6 +53,7 @@ test "struct contains slice of itself" {
52	53
53	54	test "struct contains aligned slice of itself" {
54	55	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
55	57
56	58	var other_nodes = [_]NodeAligned{
57	59	NodeAligned{

test/behavior/switch.zig+37

...	...	@@ -5,6 +5,8 @@ const expectError = std.testing.expectError;
5	5	const expectEqual = std.testing.expectEqual;
6	6
7	7	test "switch with numbers" {
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9
8	10	try testSwitchWithNumbers(13);
9	11	}
10	12
...	...	@@ -18,6 +20,8 @@ fn testSwitchWithNumbers(x: u32) !void {
18	20	}
19	21
20	22	test "switch with all ranges" {
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	24
21	25	try expect(testSwitchWithAllRanges(50, 3) == 1);
22	26	try expect(testSwitchWithAllRanges(101, 0) == 2);
23	27	try expect(testSwitchWithAllRanges(300, 5) == 3);
...	...	@@ -49,6 +53,8 @@ test "implicit comptime switch" {
49	53	}
50	54
51	55	test "switch on enum" {
	56	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	57
52	58	const fruit = Fruit.Orange;
53	59	nonConstSwitchOnEnum(fruit);
54	60	}
...	...	@@ -66,6 +72,8 @@ fn nonConstSwitchOnEnum(fruit: Fruit) void {
66	72	}
67	73
68	74	test "switch statement" {
	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	76
69	77	try nonConstSwitch(SwitchStatementFoo.C);
70	78	}
71	79	fn nonConstSwitch(foo: SwitchStatementFoo) !void {
...	...	@@ -81,6 +89,7 @@ const SwitchStatementFoo = enum { A, B, C, D };
81	89
82	90	test "switch with multiple expressions" {
83	91	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	92	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
84	93
85	94	const x = switch (returnsFive()) {
86	95	1, 2, 3 => 1,
...	...	@@ -94,6 +103,8 @@ fn returnsFive() i32 {
94	103	}
95	104
96	105	test "switch on type" {
	106	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	107
97	108	try expect(trueIfBoolFalseOtherwise(bool));
98	109	try expect(!trueIfBoolFalseOtherwise(i32));
99	110	}
...	...	@@ -106,6 +117,8 @@ fn trueIfBoolFalseOtherwise(comptime T: type) bool {
106	117	}
107	118
108	119	test "switching on booleans" {
	120	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	121
109	122	try testSwitchOnBools();
110	123	comptime try testSwitchOnBools();
111	124	}
...	...	@@ -157,6 +170,8 @@ test "undefined.u0" {
157	170	}
158	171
159	172	test "switch with disjoint range" {
	173	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	174
160	175	var q: u8 = 0;
161	176	switch (q) {
162	177	0...125 => {},
...	...	@@ -199,6 +214,8 @@ fn poll() void {
199	214	}
200	215
201	216	test "switch on global mutable var isn't constant-folded" {
	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	218
202	219	while (state < 2) {
203	220	poll();
204	221	}
...	...	@@ -214,6 +231,7 @@ test "switch prong with variable" {
214	231	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
215	232	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
216	233	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	234	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
217	235
218	236	try switchProngWithVarFn(SwitchProngWithVarEnum{ .One = 13 });
219	237	try switchProngWithVarFn(SwitchProngWithVarEnum{ .Two = 13.0 });
...	...	@@ -237,6 +255,7 @@ fn switchProngWithVarFn(a: SwitchProngWithVarEnum) !void {
237	255	test "switch on enum using pointer capture" {
238	256	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
239	257	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	258	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
240	259
241	260	try testSwitchEnumPtrCapture();
242	261	comptime try testSwitchEnumPtrCapture();
...	...	@@ -256,6 +275,7 @@ fn testSwitchEnumPtrCapture() !void {
256	275
257	276	test "switch handles all cases of number" {
258	277	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	278	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
259	279
260	280	try testSwitchHandleAllCases();
261	281	comptime try testSwitchHandleAllCases();
...	...	@@ -296,6 +316,7 @@ fn testSwitchHandleAllCasesRange(x: u8) u8 {
296	316	test "switch on union with some prongs capturing" {
297	317	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
298	318	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	319	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
299	320
300	321	const X = union(enum) {
301	322	a,
...	...	@@ -331,6 +352,7 @@ test "switch on const enum with var" {
331	352
332	353	test "anon enum literal used in switch on union enum" {
333	354	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	355	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
334	356
335	357	const Foo = union(enum) {
336	358	a: i32,
...	...	@@ -345,6 +367,8 @@ test "anon enum literal used in switch on union enum" {
345	367	}
346	368
347	369	test "switch all prongs unreachable" {
	370	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	371
348	372	try testAllProngsUnreachable();
349	373	comptime try testAllProngsUnreachable();
350	374	}
...	...	@@ -367,6 +391,7 @@ fn switchWithUnreachable(x: i32) i32 {
367	391
368	392	test "capture value of switch with all unreachable prongs" {
369	393	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	394	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
370	395
371	396	const x = return_a_number() catch \|err\| switch (err) {
372	397	else => unreachable,
...	...	@@ -380,6 +405,7 @@ fn return_a_number() anyerror!i32 {
380	405
381	406	test "switch on integer with else capturing expr" {
382	407	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	408	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
383	409
384	410	const S = struct {
385	411	fn doTheTest() !void {
...	...	@@ -399,6 +425,7 @@ test "else prong of switch on error set excludes other cases" {
399	425	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
400	426	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
401	427	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	428	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
402	429
403	430	const S = struct {
404	431	fn doTheTest() !void {
...	...	@@ -433,6 +460,7 @@ test "switch prongs with error set cases make a new error set type for capture v
433	460	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
434	461	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
435	462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	463	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
436	464
437	465	const S = struct {
438	466	fn doTheTest() !void {
...	...	@@ -467,6 +495,7 @@ test "switch prongs with error set cases make a new error set type for capture v
467	495
468	496	test "return result loc and then switch with range implicit casted to error union" {
469	497	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	498	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
470	499
471	500	const S = struct {
472	501	fn doTheTest() !void {
...	...	@@ -487,6 +516,7 @@ test "switch with null and T peer types and inferred result location type" {
487	516	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
488	517	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
489	518	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	519	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
490	520
491	521	const S = struct {
492	522	fn doTheTest(c: u8) !void {
...	...	@@ -507,6 +537,7 @@ test "switch prongs with cases with identical payload types" {
507	537	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
508	538	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
509	539	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	540	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
510	541
511	542	const Union = union(enum) {
512	543	A: usize,
...	...	@@ -550,6 +581,7 @@ test "switch prongs with cases with identical payload types" {
550	581	test "switch on pointer type" {
551	582	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
552	583	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	584	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
553	585
554	586	const S = struct {
555	587	const X = struct {
...	...	@@ -597,6 +629,7 @@ test "switch capture copies its payload" {
597	629	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
598	630	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
599	631	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	632	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
600	633
601	634	const S = struct {
602	635	fn doTheTest() !void {
...	...	@@ -619,6 +652,8 @@ test "switch capture copies its payload" {
619	652	}
620	653
621	654	test "capture of integer forwards the switch condition directly" {
	655	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	656
622	657	const S = struct {
623	658	fn foo(x: u8) !void {
624	659	switch (x) {
...	...	@@ -638,6 +673,8 @@ test "capture of integer forwards the switch condition directly" {
638	673	}
639	674
640	675	test "enum value without tag name used as switch item" {
	676	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	677
641	678	const E = enum(u32) {
642	679	a = 1,
643	680	b = 2,

test/behavior/switch_prong_err_enum.zig+2

...	...	@@ -24,6 +24,8 @@ test "switch prong returns error enum" {
24	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
25	25	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
26	26	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	27	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	28
27	29	switch (doThing(17) catch unreachable) {
28	30	FormValue.Address => \|payload\| {
29	31	try expect(payload == 1);

test/behavior/switch_prong_implicit_cast.zig+2

...	...	@@ -18,6 +18,8 @@ test "switch prong implicit cast" {
18	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
20	20	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	21	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	22
21	23	const result = switch (foo(2) catch unreachable) {
22	24	FormValue.One => false,
23	25	FormValue.Two => \|x\| x,

test/behavior/this.zig+1

...	...	@@ -26,6 +26,7 @@ test "this refer to module call private fn" {
26	26
27	27	test "this refer to container" {
28	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
29	30
30	31	var pt: Point(i32) = undefined;
31	32	pt.x = 12;

test/behavior/threadlocal.zig+3

...	...	@@ -9,6 +9,7 @@ test "thread local variable" {
9	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch != .x86_64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
	12	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
12	13
13	14	const S = struct {
14	15	threadlocal var t: i32 = 1234;
...	...	@@ -24,6 +25,7 @@ test "pointer to thread local array" {
24	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
25	26	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch != .x86_64) return error.SkipZigTest; // TODO
26	27	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
	28	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27	29
28	30	const s = "Hello world";
29	31	std.mem.copy(u8, buffer[0..], s);
...	...	@@ -39,6 +41,7 @@ test "reference a global threadlocal variable" {
39	41	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40	42	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch != .x86_64) return error.SkipZigTest; // TODO
41	43	if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // TODO
	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42	45
43	46	_ = nrfx_uart_rx(&g_uart0);
44	47	}

test/behavior/translate_c_macros.zig+16

...	...	@@ -8,6 +8,8 @@ const h = @cImport(@cInclude("behavior/translate_c_macros.h"));
8	8	const latin1 = @cImport(@cInclude("behavior/translate_c_macros_not_utf8.h"));
9	9
10	10	test "casting to void with a macro" {
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	12
11	13	h.IGNORE_ME_1(42);
12	14	h.IGNORE_ME_2(42);
13	15	h.IGNORE_ME_3(42);
...	...	@@ -24,6 +26,7 @@ test "initializer list expression" {
24	26	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
25	27	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	29	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27	30
28	31	try expectEqual(h.Color{
29	32	.r = 200,
...	...	@@ -35,12 +38,15 @@ test "initializer list expression" {
35	38
36	39	test "sizeof in macros" {
37	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
38	42
39	43	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF(u32));
40	44	try expect(@as(c_int, @sizeOf(u32)) == h.MY_SIZEOF2(u32));
41	45	}
42	46
43	47	test "reference to a struct type" {
	48	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	49
44	50	try expect(@sizeOf(h.struct_Foo) == h.SIZE_OF_FOO);
45	51	}
46	52
...	...	@@ -49,6 +55,7 @@ test "cast negative integer to pointer" {
49	55	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
50	56	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
51	57	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	58	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
52	59
53	60	try expectEqual(@intToPtr(?*anyopaque, @bitCast(usize, @as(isize, -1))), h.MAP_FAILED);
54	61	}
...	...	@@ -58,6 +65,7 @@ test "casting to union with a macro" {
58	65	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
59	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
60	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
61	69
62	70	const l: c_long = 42;
63	71	const d: f64 = 2.0;
...	...	@@ -74,6 +82,7 @@ test "casting or calling a value with a paren-surrounded macro" {
74	82	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
75	83	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
76	84	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	85	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
77	86
78	87	const l: c_long = 42;
79	88	const casted = h.CAST_OR_CALL_WITH_PARENS(c_int, l);
...	...	@@ -93,6 +102,7 @@ test "nested comma operator" {
93	102	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
94	103	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
95	104	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	105	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
96	106
97	107	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR);
98	108	try expectEqual(@as(c_int, 3), h.NESTED_COMMA_OPERATOR_LHS);
...	...	@@ -103,6 +113,7 @@ test "cast functions" {
103	113	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
104	114	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
105	115	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	116	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
106	117
107	118	const S = struct {
108	119	fn foo() void {}
...	...	@@ -116,6 +127,7 @@ test "large integer macro" {
116	127	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
117	128	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
118	129	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	130	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
119	131
120	132	try expectEqual(@as(c_ulonglong, 18446744073709550592), h.LARGE_INT);
121	133	}
...	...	@@ -125,6 +137,7 @@ test "string literal macro with embedded tab character" {
125	137	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
126	138	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
127	139	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	140	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
128	141
129	142	try expectEqualStrings("hello\t", h.EMBEDDED_TAB);
130	143	}
...	...	@@ -134,6 +147,7 @@ test "string and char literals that are not UTF-8 encoded. Issue #12784" {
134	147	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
135	148	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
136	149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	150	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
137	151
138	152	try expectEqual(@as(u8, '\xA9'), latin1.UNPRINTABLE_CHAR);
139	153	try expectEqualStrings("\xA9\xA9\xA9", latin1.UNPRINTABLE_STRING);
...	...	@@ -144,6 +158,7 @@ test "Macro that uses division operator. Issue #13162" {
144	158	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
145	159	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
146	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	161	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
147	162
148	163	try expectEqual(@as(c_int, 42), h.DIVIDE_CONSTANT(@as(c_int, 42_000)));
149	164	try expectEqual(@as(c_uint, 42), h.DIVIDE_CONSTANT(@as(c_uint, 42_000)));
...	...	@@ -177,6 +192,7 @@ test "Macro that uses remainder operator. Issue #13346" {
177	192	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
178	193	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
179	194	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
180	196
181	197	try expectEqual(@as(c_int, 2_010), h.REMAINDER_CONSTANT(@as(c_int, 42_010)));
182	198	try expectEqual(@as(c_uint, 2_030), h.REMAINDER_CONSTANT(@as(c_uint, 42_030)));

test/behavior/truncate.zig+1

...	...	@@ -65,6 +65,7 @@ test "truncate on vectors" {
65	65	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
66	66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
67	67	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	68	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68	69
69	70	const S = struct {
70	71	fn doTheTest() !void {

test/behavior/try.zig+1

...	...	@@ -4,6 +4,7 @@ const expect = std.testing.expect;
4	4
5	5	test "try on error union" {
6	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	7	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
7	8
8	9	try tryOnErrorUnionImpl();
9	10	comptime try tryOnErrorUnionImpl();

test/behavior/tuple.zig+7

...	...	@@ -6,6 +6,7 @@ const expect = testing.expect;
6	6	test "tuple concatenation" {
7	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	9	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
9	10
10	11	const S = struct {
11	12	fn doTheTest() !void {
...	...	@@ -48,6 +49,7 @@ test "tuple multiplication" {
48	49	test "more tuple concatenation" {
49	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
50	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	52	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
51	53
52	54	const T = struct {
53	55	fn consume_tuple(tuple: anytype, len: usize) !void {
...	...	@@ -124,6 +126,7 @@ test "tuple initializer for var" {
124	126	test "array-like initializer for tuple types" {
125	127	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
126	128	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	129	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127	130
128	131	const T = @Type(.{
129	132	.Struct = .{
...	...	@@ -208,6 +211,7 @@ test "fieldParentPtr of tuple" {
208	211	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
209	212	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
210	213	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	214	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211	215
212	216	var x: u32 = 0;
213	217	const tuple = .{ x, x };
...	...	@@ -218,6 +222,7 @@ test "fieldParentPtr of anon struct" {
218	222	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
219	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
220	224	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
	225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
221	226
222	227	var x: u32 = 0;
223	228	const anon_st = .{ .foo = x, .bar = x };
...	...	@@ -258,6 +263,7 @@ test "tuple in tuple passed to generic function" {
258	263	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
259	264	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
260	265	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
261	267
262	268	const S = struct {
263	269	fn pair(x: f32, y: f32) std.meta.Tuple(&.{ f32, f32 }) {
...	...	@@ -277,6 +283,7 @@ test "coerce tuple to tuple" {
277	283	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
278	284	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
279	285	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
	286	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
280	287
281	288	const T = std.meta.Tuple(&.{u8});
282	289	const S = struct {

test/behavior/type.zig+2

...	...	@@ -203,6 +203,7 @@ test "Type.Opaque" {
203	203	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
204	204	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
205	205	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	206	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
206	207
207	208	const Opaque = @Type(.{
208	209	.Opaque = .{
...	...	@@ -261,6 +262,7 @@ test "Type.Struct" {
261	262	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
262	263	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
263	264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	265	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
264	266
265	267	const A = @Type(@typeInfo(struct { x: u8, y: u32 }));
266	268	const infoA = @typeInfo(A).Struct;

test/behavior/type_info.zig+7

...	...	@@ -160,6 +160,7 @@ test "type info: error set, error union info, anyerror" {
160	160	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161	161	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
162	162	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	163	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
163	164
164	165	try testErrorSet();
165	166	comptime try testErrorSet();
...	...	@@ -191,6 +192,7 @@ test "type info: error set single value" {
191	192	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	193	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
193	194	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
194	196
195	197	const TestSet = error.One;
196	198
...	...	@@ -204,6 +206,7 @@ test "type info: error set merged" {
204	206	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
205	207	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
206	208	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	209	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
207	210
208	211	const TestSet = error{ One, Two } \|\| error{Three};
209	212
...	...	@@ -219,6 +222,7 @@ test "type info: enum info" {
219	222	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220	223	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	225	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222	226
223	227	try testEnum();
224	228	comptime try testEnum();
...	...	@@ -282,6 +286,7 @@ fn testUnion() !void {
282	286
283	287	test "type info: struct info" {
284	288	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	289	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
285	290
286	291	try testStruct();
287	292	comptime try testStruct();
...	...	@@ -508,6 +513,7 @@ test "type info for async frames" {
508	513	test "Declarations are returned in declaration order" {
509	514	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
510	515	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	516	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
511	517
512	518	const S = struct {
513	519	const a = 1;
...	...	@@ -531,6 +537,7 @@ test "Struct.is_tuple for anon list literal" {
531	537	test "Struct.is_tuple for anon struct literal" {
532	538	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
533	539	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	540	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
534	541
535	542	const info = @typeInfo(@TypeOf(.{ .a = 0 }));
536	543	try expect(!info.Struct.is_tuple);

test/behavior/typename.zig+8

...	...	@@ -15,6 +15,7 @@ test "anon fn param" {
15	15	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
17	17	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	18	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
18	19
19	20	// https://github.com/ziglang/zig/issues/9339
20	21	try expectEqualStringsIgnoreDigits(
...	...	@@ -40,6 +41,7 @@ test "anon field init" {
40	41	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
41	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
42	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
43	45
44	46	const Foo = .{
45	47	.T1 = struct {},
...	...	@@ -65,6 +67,7 @@ test "basic" {
65	67	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
66	68	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
67	69	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	70	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
68	71
69	72	try expectEqualStrings(@typeName(i64), "i64");
70	73	try expectEqualStrings(@typeName(usize), "usize");
...	...	@@ -75,6 +78,7 @@ test "top level decl" {
75	78	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
76	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
77	80	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	81	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
78	82
79	83	try expectEqualStrings(
80	84	"behavior.typename.A_Struct",
...	...	@@ -124,6 +128,7 @@ test "fn param" {
124	128	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
125	129	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
126	130	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	131	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
127	132
128	133	// https://github.com/ziglang/zig/issues/675
129	134	try expectEqualStrings(
...	...	@@ -194,6 +199,7 @@ test "local variable" {
194	199	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
195	200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
196	201	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	202	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
197	203
198	204	const Foo = struct { a: u32 };
199	205	const Bar = union { a: u32 };
...	...	@@ -212,6 +218,7 @@ test "comptime parameters not converted to anytype in function type" {
212	218	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
213	219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
214	220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
215	222
216	223	const T = fn (fn (type) void, void) void;
217	224	try expectEqualStrings("fn(comptime fn(comptime type) void, void) void", @typeName(T));
...	...	@@ -221,6 +228,7 @@ test "anon name strategy used in sub expression" {
221	228	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
222	229	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
223	230	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	231	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224	232
225	233	const S = struct {
226	234	fn getTheName() []const u8 {

test/behavior/undefined.zig+4

...	...	@@ -17,6 +17,7 @@ test "init static array to undefined" {
17	17	// C backend does not yet support returning arrays, so it fails
18	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	19	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	20	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
20	21
21	22	try expect(static_array[0] == 1);
22	23	try expect(static_array[4] == 2);
...	...	@@ -46,6 +47,7 @@ fn setFooX(foo: *Foo) void {
46	47	test "assign undefined to struct" {
47	48	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
48	49	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	50	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
49	51
50	52	comptime {
51	53	var foo: Foo = undefined;
...	...	@@ -62,6 +64,7 @@ test "assign undefined to struct" {
62	64	test "assign undefined to struct with method" {
63	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
64	66	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	67	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
65	68
66	69	comptime {
67	70	var foo: Foo = undefined;
...	...	@@ -77,6 +80,7 @@ test "assign undefined to struct with method" {
77	80
78	81	test "type name of undefined" {
79	82	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	83	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
80	84
81	85	const x = undefined;
82	86	try expect(mem.eql(u8, @typeName(@TypeOf(x)), "@TypeOf(undefined)"));

test/behavior/underscore.zig+1

...	...	@@ -8,6 +8,7 @@ test "ignore lval with underscore" {
8	8
9	9	test "ignore lval with underscore (while loop)" {
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	while (optionalReturnError()) \|_\| {
13	14	while (optionalReturnError()) \|_\| {

test/behavior/union.zig+54

...	...	@@ -14,6 +14,7 @@ test "basic unions with floats" {
14	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
15	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	16	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	17	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
17	18
18	19	var foo = FooWithFloats{ .int = 1 };
19	20	try expect(foo.int == 1);
...	...	@@ -29,6 +30,7 @@ test "init union with runtime value - floats" {
29	30	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
30	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	34
33	35	var foo: FooWithFloats = undefined;
34	36
...	...	@@ -39,6 +41,7 @@ test "init union with runtime value - floats" {
39	41	test "basic unions" {
40	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
41	43	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
42	45
43	46	var foo = Foo{ .int = 1 };
44	47	try expect(foo.int == 1);
...	...	@@ -56,6 +59,7 @@ const Foo = union {
56	59	test "init union with runtime value" {
57	60	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
58	61	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	62	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
59	63
60	64	var foo: Foo = undefined;
61	65
...	...	@@ -93,6 +97,7 @@ const FooExtern = extern union {
93	97
94	98	test "basic extern unions" {
95	99	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	100	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
96	101
97	102	var foo = FooExtern{ .int = 1 };
98	103	try expect(foo.int == 1);
...	...	@@ -163,6 +168,7 @@ test "access a member of tagged union with conflicting enum tag name" {
163	168	test "constant tagged union with payload" {
164	169	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
165	170	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	171	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
166	172
167	173	var empty = TaggedUnionWithPayload{ .Empty = {} };
168	174	var full = TaggedUnionWithPayload{ .Full = 13 };
...	...	@@ -212,6 +218,7 @@ test "union with specified enum tag" {
212	218	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
213	219	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
214	220	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	221	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
215	222
216	223	try doTest();
217	224	comptime try doTest();
...	...	@@ -221,6 +228,7 @@ test "packed union generates correctly aligned type" {
221	228	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
222	229	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
223	230	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	231	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
224	232
225	233	const U = packed union {
226	234	f1: *const fn () error{TestUnexpectedResult}!void,
...	...	@@ -259,6 +267,7 @@ fn testComparison() !void {
259	267	test "comparison between union and enum literal" {
260	268	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
261	269	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	270	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
262	271
263	272	try testComparison();
264	273	comptime try testComparison();
...	...	@@ -273,6 +282,7 @@ const TheUnion = union(TheTag) {
273	282	test "cast union to tag type of union" {
274	283	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
275	284	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	285	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
276	286
277	287	try testCastUnionToTag();
278	288	comptime try testCastUnionToTag();
...	...	@@ -292,6 +302,7 @@ test "union field access gives the enum values" {
292	302	test "cast tag type of union to union" {
293	303	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
294	304	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	305	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
295	306
296	307	var x: Value2 = Letter2.B;
297	308	try expect(@as(Letter2, x) == Letter2.B);
...	...	@@ -306,6 +317,7 @@ const Value2 = union(Letter2) {
306	317	test "implicit cast union to its tag type" {
307	318	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
308	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	320	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
309	321
310	322	var x: Value2 = Letter2.B;
311	323	try expect(x == Letter2.B);
...	...	@@ -325,6 +337,7 @@ pub const PackThis = union(enum) {
325	337	test "constant packed union" {
326	338	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
327	339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	340	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
328	341
329	342	try testConstPackedUnion(&[_]PackThis{PackThis{ .StringLiteral = 1 }});
330	343	}
...	...	@@ -343,6 +356,7 @@ test "simple union(enum(u32))" {
343	356	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
344	357	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
345	358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	359	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
346	360
347	361	var x = MultipleChoice.C;
348	362	try expect(x == MultipleChoice.C);
...	...	@@ -368,6 +382,7 @@ test "tagged union initialization with runtime void" {
368	382	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
369	383	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
370	384	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	385	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
371	386
372	387	try expect(testTaggedUnionInit({}));
373	388	}
...	...	@@ -388,6 +403,7 @@ test "tagged union with no payloads" {
388	403	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
389	404	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
390	405	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	406	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
391	407
392	408	const a = UnionEnumNoPayloads{ .B = {} };
393	409	switch (a) {
...	...	@@ -398,6 +414,7 @@ test "tagged union with no payloads" {
398	414
399	415	test "union with only 1 field casted to its enum type" {
400	416	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	417	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
401	418
402	419	const Literal = union(enum) {
403	420	Number: f64,
...	...	@@ -434,6 +451,7 @@ test "global union with single field is correctly initialized" {
434	451	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
435	452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
436	453	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	454	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
437	455
438	456	glbl = Foo1{
439	457	.f = @typeInfo(Foo1).Union.fields[0].field_type{ .x = 123 },
...	...	@@ -452,6 +470,7 @@ test "initialize global array of union" {
452	470	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
453	471	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
454	472	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	473	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
455	474
456	475	glbl_array[1] = FooUnion{ .U1 = 2 };
457	476	glbl_array[0] = FooUnion{ .U0 = 1 };
...	...	@@ -462,6 +481,7 @@ test "initialize global array of union" {
462	481	test "update the tag value for zero-sized unions" {
463	482	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
464	483	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	484	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
465	485
466	486	const S = union(enum) {
467	487	U0: void,
...	...	@@ -478,6 +498,7 @@ test "union initializer generates padding only if needed" {
478	498	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
479	499	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
480	500	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	501	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
481	502
482	503	const U = union(enum) {
483	504	A: u24,
...	...	@@ -489,6 +510,7 @@ test "union initializer generates padding only if needed" {
489	510
490	511	test "runtime tag name with single field" {
491	512	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	513	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
492	514
493	515	const U = union(enum) {
494	516	A: i32,
...	...	@@ -501,6 +523,7 @@ test "runtime tag name with single field" {
501	523	test "method call on an empty union" {
502	524	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
503	525	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	526	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
504	527
505	528	const S = struct {
506	529	const MyUnion = union(MyUnionTag) {
...	...	@@ -541,6 +564,7 @@ const Baz = enum { A, B, C, D };
541	564	test "tagged union type" {
542	565	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
543	566	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	567	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
544	568
545	569	const foo1 = TaggedFoo{ .One = 13 };
546	570	const foo2 = TaggedFoo{
...	...	@@ -563,6 +587,7 @@ test "tagged union type" {
563	587	test "tagged union as return value" {
564	588	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
565	589	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	590	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
566	591
567	592	switch (returnAnInt(13)) {
568	593	TaggedFoo.One => \|value\| try expect(value == 13),
...	...	@@ -578,6 +603,7 @@ test "tagged union with all void fields but a meaningful tag" {
578	603	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
579	604	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
580	605	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	606	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
581	607
582	608	const S = struct {
583	609	const B = union(enum) {
...	...	@@ -606,6 +632,7 @@ test "union(enum(u32)) with specified and unspecified tag values" {
606	632	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
607	633	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
608	634	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	635	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
609	636
610	637	comptime try expect(Tag(Tag(MultipleChoice2)) == u32);
611	638	try testEnumWithSpecifiedAndUnspecifiedTagValues(MultipleChoice2{ .C = 123 });
...	...	@@ -642,6 +669,7 @@ fn testEnumWithSpecifiedAndUnspecifiedTagValues(x: MultipleChoice2) !void {
642	669	test "switch on union with only 1 field" {
643	670	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
644	671	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	672	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
645	673
646	674	var r: PartialInst = undefined;
647	675	r = PartialInst.Compiled;
...	...	@@ -670,6 +698,7 @@ const PartialInstWithPayload = union(enum) {
670	698
671	699	test "union with only 1 field casted to its enum type which has enum value specified" {
672	700	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	701	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
673	702
674	703	const Literal = union(enum) {
675	704	Number: f64,
...	...	@@ -695,6 +724,7 @@ test "union with only 1 field casted to its enum type which has enum value speci
695	724	test "@enumToInt works on unions" {
696	725	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
697	726	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	727	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
698	728
699	729	const Bar = union(enum) {
700	730	A: bool,
...	...	@@ -754,6 +784,7 @@ test "return union init with void payload" {
754	784	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
755	785	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
756	786	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	787	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
757	788
758	789	const S = struct {
759	790	fn entry() !void {
...	...	@@ -779,6 +810,7 @@ test "@unionInit stored to a const" {
779	810	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
780	811	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
781	812	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	813	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
782	814
783	815	const S = struct {
784	816	const U = union(enum) {
...	...	@@ -806,6 +838,7 @@ test "@unionInit stored to a const" {
806	838	test "@unionInit can modify a union type" {
807	839	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
808	840	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	841	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
809	842
810	843	const UnionInitEnum = union(enum) {
811	844	Boolean: bool,
...	...	@@ -828,6 +861,7 @@ test "@unionInit can modify a union type" {
828	861	test "@unionInit can modify a pointer value" {
829	862	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
830	863	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	864	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
831	865
832	866	const UnionInitEnum = union(enum) {
833	867	Boolean: bool,
...	...	@@ -847,6 +881,7 @@ test "@unionInit can modify a pointer value" {
847	881	test "union no tag with struct member" {
848	882	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
849	883	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	884	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
850	885
851	886	const Struct = struct {};
852	887	const Union = union {
...	...	@@ -882,6 +917,7 @@ test "anonymous union literal syntax" {
882	917	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
883	918	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
884	919	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	920	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
885	921
886	922	const S = struct {
887	923	const Number = union {
...	...	@@ -907,6 +943,7 @@ test "anonymous union literal syntax" {
907	943	test "function call result coerces from tagged union to the tag" {
908	944	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
909	945	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	946	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
910	947
911	948	const S = struct {
912	949	const Arch = union(enum) {
...	...	@@ -941,6 +978,7 @@ test "cast from anonymous struct to union" {
941	978	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
942	979	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
943	980	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	981	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
944	982
945	983	const S = struct {
946	984	const U = union(enum) {
...	...	@@ -973,6 +1011,7 @@ test "cast from pointer to anonymous struct to pointer to union" {
973	1011	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
974	1012	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
975	1013	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1014	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
976	1015
977	1016	const S = struct {
978	1017	const U = union(enum) {
...	...	@@ -1003,6 +1042,7 @@ test "cast from pointer to anonymous struct to pointer to union" {
1003	1042	test "switching on non exhaustive union" {
1004	1043	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1005	1044	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1045	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1006	1046
1007	1047	const S = struct {
1008	1048	const E = enum(u8) {
...	...	@@ -1029,6 +1069,7 @@ test "switching on non exhaustive union" {
1029	1069	test "containers with single-field enums" {
1030	1070	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1031	1071	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1072	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1032	1073
1033	1074	const S = struct {
1034	1075	const A = union(enum) { f1 };
...	...	@@ -1058,6 +1099,7 @@ test "@unionInit on union with tag but no fields" {
1058	1099	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1059	1100	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1060	1101	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1102	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1061	1103
1062	1104	const S = struct {
1063	1105	const Type = enum(u8) { no_op = 105 };
...	...	@@ -1106,6 +1148,7 @@ test "global variable struct contains union initialized to non-most-aligned fiel
1106	1148	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1107	1149	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1108	1150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1151	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1109	1152
1110	1153	const T = struct {
1111	1154	const U = union(enum) {
...	...	@@ -1132,6 +1175,7 @@ test "union with no result loc initiated with a runtime value" {
1132	1175	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1133	1176	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1134	1177	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1178	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1135	1179
1136	1180	const U = union {
1137	1181	a: u32,
...	...	@@ -1148,6 +1192,7 @@ test "union with a large struct field" {
1148	1192	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1149	1193	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1150	1194	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1195	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1151	1196
1152	1197	const S = struct {
1153	1198	a: [8]usize,
...	...	@@ -1180,6 +1225,7 @@ test "comptime equality of extern unions with same tag" {
1180	1225	test "union tag is set when initiated as a temporary value at runtime" {
1181	1226	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1182	1227	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1228	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1183	1229
1184	1230	const U = union(enum) {
1185	1231	a,
...	...	@@ -1198,6 +1244,7 @@ test "extern union most-aligned field is smaller" {
1198	1244	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1199	1245	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1200	1246	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1247	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1201	1248
1202	1249	const U = extern union {
1203	1250	in6: extern struct {
...	...	@@ -1216,6 +1263,7 @@ test "return an extern union from C calling convention" {
1216	1263	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1217	1264	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1218	1265	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	1266	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1219	1267
1220	1268	const namespace = struct {
1221	1269	const S = extern struct {
...	...	@@ -1246,6 +1294,7 @@ test "noreturn field in union" {
1246	1294	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1247	1295	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1248	1296	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
	1297	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1249	1298
1250	1299	const U = union(enum) {
1251	1300	a: u32,
...	...	@@ -1296,6 +1345,7 @@ test "noreturn field in union" {
1296	1345	test "union and enum field order doesn't match" {
1297	1346	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1298	1347	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1348	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1299	1349
1300	1350	const MyTag = enum(u32) {
1301	1351	b = 1337,
...	...	@@ -1321,6 +1371,7 @@ test "@unionInit uses tag value instead of field index" {
1321	1371	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1322	1372	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1323	1373	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1374	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1324	1375
1325	1376	const E = enum(u8) {
1326	1377	b = 255,
...	...	@@ -1346,6 +1397,7 @@ test "@unionInit uses tag value instead of field index" {
1346	1397	test "union field ptr - zero sized payload" {
1347	1398	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1348	1399	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1400	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1349	1401
1350	1402	const U = union {
1351	1403	foo: void,
...	...	@@ -1359,6 +1411,7 @@ test "union field ptr - zero sized payload" {
1359	1411	test "union field ptr - zero sized field" {
1360	1412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1361	1413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1362	1415
1363	1416	const U = union {
1364	1417	foo: void,
...	...	@@ -1374,6 +1427,7 @@ test "packed union in packed struct" {
1374	1427	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1375	1428	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1376	1429	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
	1430	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1377	1431
1378	1432	const S = packed struct {
1379	1433	nested: packed union {

test/behavior/union_with_members.zig+1

...	...	@@ -21,6 +21,7 @@ test "enum with members" {
21	21	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
22	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	24	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
24	25
25	26	const a = ET{ .SINT = -42 };
26	27	const b = ET{ .UINT = 42 };

test/behavior/usingnamespace.zig+3

...	...	@@ -38,6 +38,7 @@ test "usingnamespace does not redeclare an imported variable" {
38	38	usingnamespace @import("usingnamespace/foo.zig");
39	39	test "usingnamespace omits mixing in private functions" {
40	40	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	41	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
41	42
42	43	try expect(@This().privateFunction());
43	44	try expect(!@This().printText());
...	...	@@ -53,12 +54,14 @@ test {
53	54	usingnamespace @import("usingnamespace/a.zig");
54	55	test "two files usingnamespace import each other" {
55	56	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	57	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
56	58
57	59	try expect(@This().ok());
58	60	}
59	61
60	62	test {
61	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	64	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
62	65
63	66	const AA = struct {
64	67	x: i32,

test/behavior/usingnamespace/import_segregation.zig+3

...	...	@@ -1,9 +1,12 @@
1	1	const expect = @import("std").testing.expect;
	2	const builtin = @import("builtin");
2	3
3	4	usingnamespace @import("foo.zig");
4	5	usingnamespace @import("bar.zig");
5	6
6	7	test "no clobbering happened" {
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
	9
7	10	@This().foo_function();
8	11	@This().bar_function();
9	12	try expect(@This().saw_foo_function);

test/behavior/var_args.zig+2

...	...	@@ -28,6 +28,7 @@ test "send void arg to var args" {
28	28
29	29	test "pass args directly" {
30	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	31	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31	32
32	33	try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
33	34	try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
...	...	@@ -40,6 +41,7 @@ fn addSomeStuff(args: anytype) i32 {
40	41
41	42	test "runtime parameter before var args" {
42	43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	44	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
43	45
44	46	try expect((try extraFn(10, .{})) == 0);
45	47	try expect((try extraFn(10, .{false})) == 1);

test/behavior/vector.zig+38

...	...	@@ -10,6 +10,7 @@ test "implicit cast vector to array - bool" {
10	10	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11	11	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
12	12	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	13	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
13	14
14	15	const S = struct {
15	16	fn doTheTest() !void {
...	...	@@ -28,6 +29,7 @@ test "vector wrap operators" {
28	29	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
29	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
30	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	32	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
31	33
32	34	const S = struct {
33	35	fn doTheTest() !void {
...	...	@@ -50,6 +52,7 @@ test "vector bin compares with mem.eql" {
50	52	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
51	53	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52	54	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	55	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
53	56
54	57	const S = struct {
55	58	fn doTheTest() !void {
...	...	@@ -73,6 +76,7 @@ test "vector int operators" {
73	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
74	77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
75	78	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	79	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
76	80
77	81	const S = struct {
78	82	fn doTheTest() !void {
...	...	@@ -94,6 +98,7 @@ test "vector float operators" {
94	98	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
95	99	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
96	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	101	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
97	102
98	103	inline for ([_]type{ f16, f32, f64, f80, f128 }) \|T\| {
99	104	const S = struct {
...	...	@@ -117,6 +122,7 @@ test "vector bit operators" {
117	122	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
118	123	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
119	124	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	125	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
120	126
121	127	const S = struct {
122	128	fn doTheTest() !void {
...	...	@@ -136,6 +142,7 @@ test "implicit cast vector to array" {
136	142	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
137	143	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
138	144	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	145	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
139	146
140	147	const S = struct {
141	148	fn doTheTest() !void {
...	...	@@ -154,6 +161,7 @@ test "array to vector" {
154	161	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
155	162	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
156	163	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	164	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
157	165
158	166	const S = struct {
159	167	fn doTheTest() !void {
...	...	@@ -173,6 +181,7 @@ test "tuple to vector" {
173	181	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
174	182	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
175	183	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
176	185
177	186	const S = struct {
178	187	fn doTheTest() !void {
...	...	@@ -195,6 +204,7 @@ test "vector casts of sizes not divisible by 8" {
195	204	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
196	205	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
197	206	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	207	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
198	208
199	209	const S = struct {
200	210	fn doTheTest() !void {
...	...	@@ -230,6 +240,7 @@ test "vector @splat" {
230	240	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
231	241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
232	242	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	243	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
233	244
234	245	if (builtin.zig_backend == .stage2_llvm and
235	246	builtin.os.tag == .macos)
...	...	@@ -277,6 +288,7 @@ test "load vector elements via comptime index" {
277	288	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
278	289	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
279	290	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	291	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
280	292
281	293	const S = struct {
282	294	fn doTheTest() !void {
...	...	@@ -299,6 +311,7 @@ test "store vector elements via comptime index" {
299	311	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
300	312	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
301	313	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	314	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
302	315
303	316	const S = struct {
304	317	fn doTheTest() !void {
...	...	@@ -327,6 +340,7 @@ test "load vector elements via runtime index" {
327	340	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
328	341	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
329	342	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	343	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
330	344
331	345	const S = struct {
332	346	fn doTheTest() !void {
...	...	@@ -349,6 +363,7 @@ test "store vector elements via runtime index" {
349	363	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
350	364	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
351	365	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	366	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
352	367
353	368	const S = struct {
354	369	fn doTheTest() !void {
...	...	@@ -372,6 +387,7 @@ test "initialize vector which is a struct field" {
372	387	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
373	388	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
374	389	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	390	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
375	391
376	392	const Vec4Obj = struct {
377	393	data: @Vector(4, f32),
...	...	@@ -395,6 +411,7 @@ test "vector comparison operators" {
395	411	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
396	412	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
397	413	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	414	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
398	415
399	416	const S = struct {
400	417	fn doTheTest() !void {
...	...	@@ -435,6 +452,7 @@ test "vector division operators" {
435	452	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
436	453	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
437	454	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	455	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
438	456
439	457	const S = struct {
440	458	fn doTheTestDiv(comptime T: type, x: @Vector(4, T), y: @Vector(4, T)) !void {
...	...	@@ -517,6 +535,7 @@ test "vector bitwise not operator" {
517	535	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
518	536	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
519	537	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	538	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
520	539
521	540	const S = struct {
522	541	fn doTheTestNot(comptime T: type, x: @Vector(4, T)) !void {
...	...	@@ -548,6 +567,7 @@ test "vector shift operators" {
548	567	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
549	568	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
550	569	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	570	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
551	571
552	572	const S = struct {
553	573	fn doTheTestShift(x: anytype, y: anytype) !void {
...	...	@@ -641,6 +661,7 @@ test "vector reduce operation" {
641	661	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
642	662	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
643	663	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	664	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
644	665
645	666	const S = struct {
646	667	fn testReduce(comptime op: std.builtin.ReduceOp, x: anytype, expected: anytype) !void {
...	...	@@ -783,6 +804,7 @@ test "vector @reduce comptime" {
783	804	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
784	805	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
785	806	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	807	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
786	808
787	809	const value = @Vector(4, i32){ 1, -1, 1, -1 };
788	810	const result = value > @splat(4, @as(i32, 0));
...	...	@@ -799,6 +821,7 @@ test "mask parameter of @shuffle is comptime scope" {
799	821	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
800	822	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
801	823	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	824	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
802	825
803	826	const __v4hi = @Vector(4, i16);
804	827	var v4_a = __v4hi{ 0, 0, 0, 0 };
...	...	@@ -818,6 +841,7 @@ test "saturating add" {
818	841	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
819	842	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
820	843	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	844	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
821	845
822	846	const S = struct {
823	847	fn doTheTest() !void {
...	...	@@ -849,6 +873,7 @@ test "saturating subtraction" {
849	873	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
850	874	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
851	875	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	876	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
852	877
853	878	const S = struct {
854	879	fn doTheTest() !void {
...	...	@@ -871,6 +896,7 @@ test "saturating multiplication" {
871	896	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
872	897	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
873	898	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	899	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
874	900
875	901	// TODO: once #9660 has been solved, remove this line
876	902	if (builtin.target.cpu.arch == .wasm32) return error.SkipZigTest;
...	...	@@ -897,6 +923,7 @@ test "saturating shift-left" {
897	923	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
898	924	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
899	925	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	926	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
900	927
901	928	const S = struct {
902	929	fn doTheTest() !void {
...	...	@@ -919,6 +946,7 @@ test "multiplication-assignment operator with an array operand" {
919	946	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
920	947	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
921	948	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
	949	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
922	950
923	951	const S = struct {
924	952	fn doTheTest() !void {
...	...	@@ -938,6 +966,7 @@ test "@addWithOverflow" {
938	966	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
939	967	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
940	968	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	969	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
941	970
942	971	const S = struct {
943	972	fn doTheTest() !void {
...	...	@@ -984,6 +1013,7 @@ test "@subWithOverflow" {
984	1013	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
985	1014	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
986	1015	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1016	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
987	1017
988	1018	const S = struct {
989	1019	fn doTheTest() !void {
...	...	@@ -1014,6 +1044,7 @@ test "@mulWithOverflow" {
1014	1044	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1015	1045	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1016	1046	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1047	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1017	1048
1018	1049	const S = struct {
1019	1050	fn doTheTest() !void {
...	...	@@ -1035,6 +1066,7 @@ test "@shlWithOverflow" {
1035	1066	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1036	1067	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1037	1068	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1069	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1038	1070
1039	1071	const S = struct {
1040	1072	fn doTheTest() !void {
...	...	@@ -1062,6 +1094,7 @@ test "loading the second vector from a slice of vectors" {
1062	1094	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1063	1095	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1064	1096	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1097	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1065	1098
1066	1099	@setRuntimeSafety(false);
1067	1100	var small_bases = [2]@Vector(2, u8){
...	...	@@ -1078,6 +1111,7 @@ test "array of vectors is copied" {
1078	1111	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1079	1112	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1080	1113	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1114	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1081	1115
1082	1116	const Vec3 = @Vector(3, i32);
1083	1117	var points = [_]Vec3{
...	...	@@ -1131,6 +1165,7 @@ test "zero divisor" {
1131	1165	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1132	1166	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1133	1167	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1168	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1134	1169
1135	1170	const zeros = @Vector(2, f32){ 0.0, 0.0 };
1136	1171	const ones = @Vector(2, f32){ 1.0, 1.0 };
...	...	@@ -1151,6 +1186,7 @@ test "zero multiplicand" {
1151	1186	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1152	1187	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1153	1188	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1189	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1154	1190
1155	1191	const zeros = @Vector(2, u32){ 0.0, 0.0 };
1156	1192	var ones = @Vector(2, u32){ 1.0, 1.0 };
...	...	@@ -1174,6 +1210,7 @@ test "@intCast to u0" {
1174	1210	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1175	1211	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1176	1212	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1213	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1177	1214
1178	1215	var zeros = @Vector(2, u32){ 0, 0 };
1179	1216	const casted = @intCast(@Vector(2, u0), zeros);
...	...	@@ -1197,6 +1234,7 @@ test "array operands to shuffle are coerced to vectors" {
1197	1234	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1198	1235	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1199	1236	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	1237	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
1200	1238
1201	1239	const mask = [5]i32{ -1, 0, 1, 2, 3 };
1202	1240

test/behavior/void.zig+2

...	...	@@ -20,6 +20,7 @@ test "compare void with void compile time known" {
20	20
21	21	test "iterate over a void slice" {
22	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	23	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
23	24
24	25	var j: usize = 0;
25	26	for (times(10)) \|_, i\| {
...	...	@@ -36,6 +37,7 @@ test "void optional" {
36	37	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
37	38	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	40	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
39	41
40	42	var x: ?void = {};
41	43	try expect(x != null);

test/behavior/while.zig+12

...	...	@@ -5,6 +5,7 @@ const assert = std.debug.assert;
5	5
6	6	test "while loop" {
7	7	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	8	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
8	9
9	10	var i: i32 = 0;
10	11	while (i < 4) {
...	...	@@ -24,6 +25,7 @@ fn whileLoop2() i32 {
24	25
25	26	test "static eval while" {
26	27	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	28	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
27	29
28	30	try expect(static_eval_while_number == 1);
29	31	}
...	...	@@ -107,6 +109,7 @@ test "while copies its payload" {
107	109	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
108	110	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109	111	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	112	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
110	113
111	114	const S = struct {
112	115	fn doTheTest() !void {
...	...	@@ -146,6 +149,7 @@ test "while with optional as condition" {
146	149	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
147	150	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
148	151	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	152	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
149	153
150	154	numbers_left = 10;
151	155	var sum: i32 = 0;
...	...	@@ -159,6 +163,7 @@ test "while with optional as condition with else" {
159	163	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
160	164	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161	165	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	166	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
162	167
163	168	numbers_left = 10;
164	169	var sum: i32 = 0;
...	...	@@ -176,6 +181,7 @@ test "while with optional as condition with else" {
176	181	test "while with error union condition" {
177	182	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
178	183	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	184	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
179	185
180	186	numbers_left = 10;
181	187	var sum: i32 = 0;
...	...	@@ -208,6 +214,7 @@ test "while on optional with else result follow else prong" {
208	214	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
209	215	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
210	216	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	217	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
211	218
212	219	const result = while (returnNull()) \|value\| {
213	220	break value;
...	...	@@ -219,6 +226,7 @@ test "while on optional with else result follow break prong" {
219	226	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220	227	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
221	228	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	229	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
222	230
223	231	const result = while (returnOptional(10)) \|value\| {
224	232	break value;
...	...	@@ -256,6 +264,7 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
256	264
257	265	test "while on error union with else result follow else prong" {
258	266	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	267	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
259	268
260	269	const result = while (returnError()) \|value\| {
261	270	break value;
...	...	@@ -265,6 +274,7 @@ test "while on error union with else result follow else prong" {
265	274
266	275	test "while on error union with else result follow break prong" {
267	276	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
	277	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
268	278
269	279	const result = while (returnSuccess(10)) \|value\| {
270	280	break value;
...	...	@@ -291,6 +301,7 @@ test "while optional 2 break statements and an else" {
291	301	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
292	302	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
293	303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	304	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
294	305
295	306	const S = struct {
296	307	fn entry(opt_t: ?bool, f: bool) !void {
...	...	@@ -310,6 +321,7 @@ test "while error 2 break statements and an else" {
310	321	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
311	322	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
312	323	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	324	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
313	325
314	326	const S = struct {
315	327	fn entry(opt_t: anyerror!bool, f: bool) !void {

test/behavior/widening.zig+5

...	...	@@ -8,6 +8,7 @@ test "integer widening" {
8	8	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
9	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
10	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	11	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
11	12
12	13	var a: u8 = 250;
13	14	var b: u16 = a;
...	...	@@ -29,6 +30,7 @@ test "integer widening u0 to u8" {
29	30	test "implicit unsigned integer to signed integer" {
30	31	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
31	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
	33	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
32	34
33	35	var a: u8 = 250;
34	36	var b: i16 = a;
...	...	@@ -40,6 +42,7 @@ test "float widening" {
40	42	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
41	43	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
42	44	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	45	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
43	46
44	47	var a: f16 = 12.34;
45	48	var b: f32 = a;
...	...	@@ -59,6 +62,7 @@ test "float widening f16 to f128" {
59	62	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
60	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
61	64	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	65	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
62	66
63	67	var x: f16 = 12.34;
64	68	var y: f128 = x;
...	...	@@ -68,6 +72,7 @@ test "float widening f16 to f128" {
68	72	test "cast small unsigned to larger signed" {
69	73	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
70	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
	75	if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
71	76
72	77	try expect(castSmallUnsignedToLargerSigned1(200) == @as(i16, 200));
73	78	try expect(castSmallUnsignedToLargerSigned2(9999) == @as(i64, 9999));