Commit 960c14206094484cee056b8806b9b8f75a84891d | zig

author	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-06-25 14:59:22+02:00
committer	Jakub Konka <kubkon@jakubkonka.com> 2022-06-25 21:16:51+02:00
log	960c14206094484cee056b8806b9b8f75a84891d
tree	0315d9420a504b2337b94c564ae029b20ddeec31
parent	76b28ed45238fff843e04e94657e2790ee95954b

stage2 ARM: implement basic intCast and error union wrapping

31 files changed, 53 insertions(+), 113 deletions(-)

src/arch/arm/CodeGen.zig+53-13

...	...	@@ -1002,18 +1002,35 @@ fn airIntCast(self: *Self, inst: Air.Inst.Index) !void {
1002	1002	if (self.liveness.isUnused(inst))
1003	1003	return self.finishAir(inst, .dead, .{ ty_op.operand, .none, .none });
1004	1004
1005		const operand_ty = self.air.typeOf(ty_op.operand);
1006	1005	const operand = try self.resolveInst(ty_op.operand);
	1006	const operand_ty = self.air.typeOf(ty_op.operand);
	1007	const dest_ty = self.air.typeOfIndex(inst);
	1008
	1009	const operand_abi_size = operand_ty.abiSize(self.target.*);
	1010	const dest_abi_size = dest_ty.abiSize(self.target.*);
1007	1011	const info_a = operand_ty.intInfo(self.target.*);
1008		const info_b = self.air.typeOfIndex(inst).intInfo(self.target.*);
1009		if (info_a.signedness != info_b.signedness)
1010		return self.fail("TODO gen intcast sign safety in semantic analysis", .{});
	1012	const info_b = dest_ty.intInfo(self.target.*);
	1013
	1014	const dst_mcv: MCValue = blk: {
	1015	if (info_a.bits == info_b.bits) {
	1016	break :blk operand;
	1017	}
	1018	if (operand_abi_size > 4 or dest_abi_size > 4) {
	1019	return self.fail("TODO implement intCast for abi sizes larger than 4", .{});
	1020	}
	1021
	1022	const operand_lock: ?RegisterLock = switch (operand) {
	1023	.register => \|reg\| self.register_manager.lockRegAssumeUnused(reg),
	1024	else => null,
	1025	};
	1026	defer if (operand_lock) \|lock\| self.register_manager.unlockReg(lock);
1011	1027
1012		if (info_a.bits == info_b.bits)
1013		return self.finishAir(inst, operand, .{ ty_op.operand, .none, .none });
	1028	const reg = try self.register_manager.allocReg(inst, gp);
	1029	try self.genSetReg(dest_ty, reg, operand);
	1030	break :blk MCValue{ .register = reg };
	1031	};
1014	1032
1015		return self.fail("TODO implement intCast for {}", .{self.target.cpu.arch});
1016		// return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
	1033	return self.finishAir(inst, dst_mcv, .{ ty_op.operand, .none, .none });
1017	1034	}
1018	1035
1019	1036	fn truncRegister(
...	...	@@ -1880,7 +1897,22 @@ fn airSetErrReturnTrace(self: *Self, inst: Air.Inst.Index) !void {
1880	1897	/// T to E!T
1881	1898	fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
1882	1899	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1883		const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion payload for {}", .{self.target.cpu.arch});
	1900	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
	1901	const error_union_ty = self.air.getRefType(ty_op.ty);
	1902	const payload_ty = error_union_ty.errorUnionPayload();
	1903	const operand = try self.resolveInst(ty_op.operand);
	1904	if (!payload_ty.hasRuntimeBitsIgnoreComptime()) break :result operand;
	1905
	1906	const abi_size = @intCast(u32, error_union_ty.abiSize(self.target.*));
	1907	const abi_align = error_union_ty.abiAlignment(self.target.*);
	1908	const stack_offset = @intCast(u32, try self.allocMem(inst, abi_size, abi_align));
	1909	const payload_off = errUnionPayloadOffset(payload_ty, self.target.*);
	1910	const err_off = errUnionErrorOffset(payload_ty, self.target.*);
	1911	try self.genSetStack(payload_ty, stack_offset - @intCast(u32, payload_off), operand);
	1912	try self.genSetStack(Type.anyerror, stack_offset - @intCast(u32, err_off), .{ .immediate = 0 });
	1913
	1914	break :result MCValue{ .stack_offset = stack_offset };
	1915	};
1884	1916	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1885	1917	}
1886	1918
...	...	@@ -1890,10 +1922,18 @@ fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
1890	1922	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1891	1923	const error_union_ty = self.air.getRefType(ty_op.ty);
1892	1924	const payload_ty = error_union_ty.errorUnionPayload();
1893		const mcv = try self.resolveInst(ty_op.operand);
1894		if (!payload_ty.hasRuntimeBits()) break :result mcv;
	1925	const operand = try self.resolveInst(ty_op.operand);
	1926	if (!payload_ty.hasRuntimeBitsIgnoreComptime()) break :result operand;
	1927
	1928	const abi_size = @intCast(u32, error_union_ty.abiSize(self.target.*));
	1929	const abi_align = error_union_ty.abiAlignment(self.target.*);
	1930	const stack_offset = @intCast(u32, try self.allocMem(inst, abi_size, abi_align));
	1931	const payload_off = errUnionPayloadOffset(payload_ty, self.target.*);
	1932	const err_off = errUnionErrorOffset(payload_ty, self.target.*);
	1933	try self.genSetStack(Type.anyerror, stack_offset - @intCast(u32, err_off), operand);
	1934	try self.genSetStack(payload_ty, stack_offset - @intCast(u32, payload_off), .undef);
1895	1935
1896		return self.fail("TODO implement wrap errunion error for non-empty payloads", .{});
	1936	break :result MCValue{ .stack_offset = stack_offset };
1897	1937	};
1898	1938	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1899	1939	}
...	...	@@ -4273,7 +4313,7 @@ fn br(self: *Self, block: Air.Inst.Index, operand: Air.Inst.Ref) !void {
4273	4313	block_data.mcv = switch (operand_mcv) {
4274	4314	.none, .dead, .unreach => unreachable,
4275	4315	.register, .stack_offset, .memory => operand_mcv,
4276		.immediate, .stack_argument_offset => blk: {
	4316	.immediate, .stack_argument_offset, .cpsr_flags => blk: {
4277	4317	const new_mcv = try self.allocRegOrMem(block, true);
4278	4318	try self.setRegOrMem(self.air.typeOfIndex(block), new_mcv, operand_mcv);
4279	4319	break :blk new_mcv;

test/behavior/align.zig-2

...	...	@@ -8,7 +8,6 @@ var foo: u8 align(4) = 100;
8	8
9	9	test "global variable alignment" {
10	10	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	11
13	12	comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
14	13	comptime try expect(@TypeOf(&foo) == *align(4) u8);
...	...	@@ -223,7 +222,6 @@ fn testBytesAlign(b: u8) !void {
223	222	test "@alignCast slices" {
224	223	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
225	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
226		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
227	225
228	226	var array align(4) = [_]u32{ 1, 1 };
229	227	const slice = array[0..];

test/behavior/array.zig-6

...	...	@@ -59,7 +59,6 @@ test "array init with mult" {
59	59
60	60	test "array literal with explicit type" {
61	61	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
62		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
63	62
64	63	const hex_mult: [4]u16 = .{ 4096, 256, 16, 1 };
65	64
...	...	@@ -112,7 +111,6 @@ test "array with sentinels" {
112	111	}
113	112
114	113	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116	114
117	115	const S = struct {
118	116	fn doTheTest(is_ct: bool) !void {
...	...	@@ -162,7 +160,6 @@ test "nested arrays of strings" {
162	160
163	161	test "nested arrays of integers" {
164	162	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
165		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
166	163	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
167	164
168	165	const array_of_numbers = [_][2]u8{
...	...	@@ -190,7 +187,6 @@ fn plusOne(x: u32) u32 {
190	187
191	188	test "single-item pointer to array indexing and slicing" {
192	189	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
193		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
194	190
195	191	try testSingleItemPtrArrayIndexSlice();
196	192	comptime try testSingleItemPtrArrayIndexSlice();
...	...	@@ -313,7 +309,6 @@ test "comptime evaluating function that takes array by value" {
313	309
314	310	test "runtime initialize array elem and then implicit cast to slice" {
315	311	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
316		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
317	312
318	313	var two: i32 = 2;
319	314	const x: []const i32 = &[_]i32{two};
...	...	@@ -322,7 +317,6 @@ test "runtime initialize array elem and then implicit cast to slice" {
322	317
323	318	test "array literal as argument to function" {
324	319	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
325		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
326	320
327	321	const S = struct {
328	322	fn entry(two: i32) !void {

test/behavior/basic.zig-9

...	...	@@ -204,7 +204,6 @@ test "opaque types" {
204	204	}
205	205
206	206	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
207		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
208	207
209	208	try expect(OpaqueA != OpaqueB);
210	209
...	...	@@ -365,7 +364,6 @@ fn testMemcpyMemset() !void {
365	364	}
366	365
367	366	test "variable is allowed to be a pointer to an opaque type" {
368		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
369	367	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
370	368
371	369	var x: i32 = 1234;
...	...	@@ -457,7 +455,6 @@ fn testArray2DConstDoublePtr(ptr: *const f32) !void {
457	455
458	456	test "double implicit cast in same expression" {
459	457	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
460		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
461	458
462	459	var x = @as(i32, @as(u16, nine()));
463	460	try expect(x == 9);
...	...	@@ -616,8 +613,6 @@ test "self reference through fn ptr field" {
616	613	}
617	614
618	615	test "global variable initialized to global variable array element" {
619		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
620
621	616	try expect(global_ptr == &gdt[0]);
622	617	}
623	618	const GDTEntry = struct {
...	...	@@ -681,7 +676,6 @@ test "explicit cast optional pointers" {
681	676	}
682	677
683	678	test "pointer comparison" {
684		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
685	679	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
686	680
687	681	const a = @as([]const u8, "a");
...	...	@@ -787,7 +781,6 @@ test "pointer to thread local array" {
787	781	threadlocal var buffer: [11]u8 = undefined;
788	782
789	783	test "auto created variables have correct alignment" {
790		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
791	784	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
792	785
793	786	const S = struct {
...	...	@@ -889,7 +882,6 @@ test "labeled block implicitly ends in a break" {
889	882	test "catch in block has correct result location" {
890	883	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
891	884	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
892		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
893	885
894	886	const S = struct {
895	887	fn open() error{A}!@This() {
...	...	@@ -920,7 +912,6 @@ test "labeled block with runtime branch forwards its result location type to bre
920	912
921	913	test "try in labeled block doesn't cast to wrong type" {
922	914	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
923		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
924	915
925	916	const S = struct {
926	917	a: u32,

test/behavior/bitreverse.zig-1

...	...	@@ -157,7 +157,6 @@ test "bitReverse vectors u0" {
157	157	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
158	158	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
159	159	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
160		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161	160
162	161	comptime try vector0();
163	162	try vector0();

test/behavior/bugs/1076.zig-1

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

test/behavior/bugs/11165.zig-4

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

test/behavior/bugs/11213.zig-1

...	...	@@ -4,7 +4,6 @@ const testing = std.testing;
4	4
5	5	test {
6	6	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
7		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
8	7
9	8	const g: error{Test}!void = error.Test;
10	9

test/behavior/bugs/3779.zig-5

...	...	@@ -8,7 +8,6 @@ const ptr_tag_name: [*:0]const u8 = tag_name;
8	8	test "@tagName() returns a string literal" {
9	9	if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
10	10	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
11		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
12	11
13	12	try std.testing.expect(*const [13:0]u8 == @TypeOf(tag_name));
14	13	try std.testing.expect(std.mem.eql(u8, "TestEnumValue", tag_name));
...	...	@@ -22,7 +21,6 @@ const ptr_error_name: [*:0]const u8 = error_name;
22	21	test "@errorName() returns a string literal" {
23	22	if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
24	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
25		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
26	24
27	25	try std.testing.expect(*const [13:0]u8 == @TypeOf(error_name));
28	26	try std.testing.expect(std.mem.eql(u8, "TestErrorCode", error_name));
...	...	@@ -36,7 +34,6 @@ const ptr_type_name: [*:0]const u8 = type_name;
36	34	test "@typeName() returns a string literal" {
37	35	if (builtin.zig_backend == .stage1) return error.SkipZigTest; // stage1 gets the type wrong
38	36	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
39		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
40	37
41	38	try std.testing.expect(*const [type_name.len:0]u8 == @TypeOf(type_name));
42	39	try std.testing.expect(std.mem.eql(u8, "behavior.bugs.3779.TestType", type_name));
...	...	@@ -49,7 +46,6 @@ const expected_contents = "hello zig\n";
49	46
50	47	test "@embedFile() returns a string literal" {
51	48	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
52		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
53	49
54	50	try std.testing.expect(*const [expected_contents.len:0]u8 == @TypeOf(actual_contents));
55	51	try std.testing.expect(std.mem.eql(u8, expected_contents, actual_contents));
...	...	@@ -63,7 +59,6 @@ fn testFnForSrc() std.builtin.SourceLocation {
63	59
64	60	test "@src() returns a struct containing 0-terminated string slices" {
65	61	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
66		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
67	62
68	63	const src = testFnForSrc();
69	64	try std.testing.expect([:0]const u8 == @TypeOf(src.file));

test/behavior/bugs/394.zig-1

...	...	@@ -11,7 +11,6 @@ const expect = @import("std").testing.expect;
11	11	const builtin = @import("builtin");
12	12
13	13	test "fixed" {
14		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	14	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
16	15	const x = S{
17	16	.x = 3,

test/behavior/bugs/7187.zig-2

...	...	@@ -3,8 +3,6 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4
5	5	test "miscompilation with bool return type" {
6		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7
8	6	var x: usize = 1;
9	7	var y: bool = getFalse();
10	8	_ = y;

test/behavior/byteswap.zig-1

...	...	@@ -118,7 +118,6 @@ test "@byteSwap vectors u0" {
118	118	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
119	119	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
120	120	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
121		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
122	121
123	122	comptime try vector0();
124	123	try vector0();

test/behavior/byval_arg_var.zig-1

...	...	@@ -6,7 +6,6 @@ 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_arm) return error.SkipZigTest;
10	9
11	10	start();
12	11	blowUpStack(10);

test/behavior/cast.zig-11

...	...	@@ -251,7 +251,6 @@ fn MakeType(comptime T: type) type {
251	251
252	252	test "implicit cast from [N]T to [c]T" {
253	253	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
254		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
255	254
256	255	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
257	256	var y: [*c]u16 = &x;
...	...	@@ -372,7 +371,6 @@ test "cast from ?[]T to ??[]T" {
372	371
373	372	test "peer type unsigned int to signed" {
374	373	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
375		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
376	374
377	375	var w: u31 = 5;
378	376	var x: u8 = 7;
...	...	@@ -451,7 +449,6 @@ fn castToOptionalTypeError(z: i32) !void {
451	449	test "implicitly cast from [0]T to anyerror![]T" {
452	450	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
453	451	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
454		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
455	452
456	453	try testCastZeroArrayToErrSliceMut();
457	454	comptime try testCastZeroArrayToErrSliceMut();
...	...	@@ -817,7 +814,6 @@ test "peer type resolution: error union after non-error" {
817	814	test "peer cast *[0]T to E![]const T" {
818	815	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
819	816	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
820		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
821	817	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
822	818
823	819	var buffer: [5]u8 = "abcde".*;
...	...	@@ -832,7 +828,6 @@ test "peer cast *[0]T to E![]const T" {
832	828	test "peer cast *[0]T to []const T" {
833	829	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
834	830	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
835		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
836	831	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
837	832
838	833	var buffer: [5]u8 = "abcde".*;
...	...	@@ -893,7 +888,6 @@ test "peer cast [:x]T to []T" {
893	888	test "peer cast [N:x]T to [N]T" {
894	889	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
895	890	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
896		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
897	891
898	892	const S = struct {
899	893	fn doTheTest() !void {
...	...	@@ -909,7 +903,6 @@ test "peer cast [N:x]T to [N]T" {
909	903	test "peer cast [N:x]T to [N]T" {
910	904	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
911	905	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
912		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
913	906
914	907	const S = struct {
915	908	fn doTheTest() !void {
...	...	@@ -1146,7 +1139,6 @@ test "implicit ptr to *anyopaque" {
1146	1139
1147	1140	test "return null from fn() anyerror!?&T" {
1148	1141	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1149		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1150	1142
1151	1143	const a = returnNullFromOptionalTypeErrorRef();
1152	1144	const b = returnNullLitFromOptionalTypeErrorRef();
...	...	@@ -1248,7 +1240,6 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
1248	1240	test "implicit cast *[0]T to E![]const u8" {
1249	1241	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1250	1242	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1251		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1252	1243
1253	1244	var x = @as(anyerror![]const u8, &[0]u8{});
1254	1245	try expect((x catch unreachable).len == 0);
...	...	@@ -1387,7 +1378,6 @@ test "peer type resolution: unreachable, null, slice" {
1387	1378
1388	1379	test "cast i8 fn call peers to i32 result" {
1389	1380	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1390		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1391	1381
1392	1382	const S = struct {
1393	1383	fn doTheTest() !void {
...	...	@@ -1417,7 +1407,6 @@ test "cast compatible optional types" {
1417	1407
1418	1408	test "coerce undefined single-item pointer of array to error union of slice" {
1419	1409	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1420		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1421	1410
1422	1411	const a = @as([*]u8, undefined)[0..0];
1423	1412	var b: error{a}![]const u8 = a;

test/behavior/comptime_memory.zig-1

...	...	@@ -5,7 +5,6 @@ const ptr_size = @sizeOf(usize);
5	5
6	6	test "type pun signed and unsigned as single pointer" {
7	7	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
8		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	8
10	9	comptime {
11	10	var x: u32 = 0;

test/behavior/enum.zig-1

...	...	@@ -24,7 +24,6 @@ fn testIntToEnumEval(x: i32) !void {
24	24	const IntToEnumNumber = enum { Zero, One, Two, Three, Four };
25	25
26	26	test "int to enum" {
27		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
28	27	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	28
30	29	try testIntToEnumEval(3);

test/behavior/error.zig-13

...	...	@@ -29,7 +29,6 @@ fn shouldBeNotEqual(a: anyerror, b: anyerror) void {
29	29	}
30	30
31	31	test "error binary operator" {
32		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
33	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
34	33
35	34	const a = errBinaryOperatorG(true) catch 3;
...	...	@@ -61,14 +60,12 @@ pub fn baz() anyerror!i32 {
61	60	}
62	61
63	62	test "error wrapping" {
64		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
65	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
66	64
67	65	try expect((baz() catch unreachable) == 15);
68	66	}
69	67
70	68	test "unwrap simple value from error" {
71		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
72	69	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
73	70
74	71	const i = unwrapSimpleValueFromErrorDo() catch unreachable;
...	...	@@ -79,7 +76,6 @@ fn unwrapSimpleValueFromErrorDo() anyerror!isize {
79	76	}
80	77
81	78	test "error return in assignment" {
82		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
83	79	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
84	80
85	81	doErrReturnInAssignment() catch unreachable;
...	...	@@ -126,7 +122,6 @@ test "debug info for optional error set" {
126	122	}
127	123
128	124	test "implicit cast to optional to error union to return result loc" {
129		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
130	125	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
131	126
132	127	const S = struct {
...	...	@@ -149,7 +144,6 @@ test "implicit cast to optional to error union to return result loc" {
149	144
150	145	test "fn returning empty error set can be passed as fn returning any error" {
151	146	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
152		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
153	147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
154	148
155	149	entry();
...	...	@@ -159,7 +153,6 @@ test "fn returning empty error set can be passed as fn returning any error" {
159	153	test "fn returning empty error set can be passed as fn returning any error - pointer" {
160	154	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
161	155	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
162		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
163	156	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
164	157
165	158	entryPtr();
...	...	@@ -249,7 +242,6 @@ fn testExplicitErrorSetCast(set1: Set1) !void {
249	242
250	243	test "comptime test error for empty error set" {
251	244	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
252		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
253	245	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
254	246
255	247	try testComptimeTestErrorEmptySet(1234);
...	...	@@ -268,7 +260,6 @@ fn testComptimeTestErrorEmptySet(x: EmptyErrorSet!i32) !void {
268	260	test "comptime err to int of error set with only 1 possible value" {
269	261	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
270	262	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
271		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
272	263	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
273	264
274	265	testErrToIntWithOnePossibleValue(error.A, @errorToInt(error.A));
...	...	@@ -323,7 +314,6 @@ fn quux_1() !i32 {
323	314	}
324	315
325	316	test "error: Zero sized error set returned with value payload crash" {
326		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
327	317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
328	318
329	319	_ = try foo3(0);
...	...	@@ -422,7 +412,6 @@ test "nested error union function call in optional unwrap" {
422	412
423	413	test "return function call to error set from error union function" {
424	414	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
425		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
426	415	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
427	416
428	417	const S = struct {
...	...	@@ -455,7 +444,6 @@ test "optional error set is the same size as error set" {
455	444
456	445	test "nested catch" {
457	446	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
458		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
459	447	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
460	448
461	449	const S = struct {
...	...	@@ -487,7 +475,6 @@ test "function pointer with return type that is error union with payload which i
487	475
488	476	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
489	477	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
490		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
491	478	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
492	479
493	480	const S = struct {

test/behavior/eval.zig-8

...	...	@@ -90,7 +90,6 @@ fn letsTryToCompareBools(a: bool, b: bool) bool {
90	90	return max(bool, a, b);
91	91	}
92	92	test "inlined block and runtime block phi" {
93		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
94	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
95	94
96	95	try expect(letsTryToCompareBools(true, true));
...	...	@@ -390,7 +389,6 @@ test "return 0 from function that has u0 return type" {
390	389	}
391	390
392	391	test "statically initialized struct" {
393		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
394	392	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
395	393
396	394	st_init_str_foo.x += 1;
...	...	@@ -502,7 +500,6 @@ test "comptime shlWithOverflow" {
502	500	}
503	501
504	502	test "const ptr to variable data changes at runtime" {
505		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
506	503	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
507	504
508	505	try expect(foo_ref.name[0] == 'a');
...	...	@@ -605,8 +602,6 @@ fn testCompTimeUIntComparisons(x: u32) void {
605	602	const hi1 = "hi";
606	603	const hi2 = hi1;
607	604	test "const global shares pointer with other same one" {
608		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
609
610	605	try assertEqualPtrs(&hi1[0], &hi2[0]);
611	606	comptime try expect(&hi1[0] == &hi2[0]);
612	607	}
...	...	@@ -976,7 +971,6 @@ test "closure capture type of runtime-known parameter" {
976	971
977	972	test "comptime break passing through runtime condition converted to runtime break" {
978	973	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
979		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
980	974
981	975	const S = struct {
982	976	fn doTheTest() !void {
...	...	@@ -1061,7 +1055,6 @@ test "comptime break operand passing through runtime condition converted to runt
1061	1055	test "comptime break operand passing through runtime switch converted to runtime break" {
1062	1056	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
1063	1057	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1064		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1065	1058
1066	1059	const S = struct {
1067	1060	fn doTheTest(runtime: u8) !void {
...	...	@@ -1227,7 +1220,6 @@ test "storing an array of type in a field" {
1227	1220	test "pass pointer to field of comptime-only type as a runtime parameter" {
1228	1221	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1229	1222	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
1230		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1231	1223
1232	1224	const S = struct {
1233	1225	const Mixed = struct {

test/behavior/fn.zig-1

...	...	@@ -197,7 +197,6 @@ fn addPointCoords(pt: Point) i32 {
197	197	}
198	198
199	199	test "pass by non-copying value through var arg" {
200		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
201	200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
202	201
203	202	try expect((try addPointCoordsVar(Point{ .x = 1, .y = 2 })) == 3);

test/behavior/if.zig-1

...	...	@@ -44,7 +44,6 @@ var global_with_val: anyerror!u32 = 0;
44	44	var global_with_err: anyerror!u32 = error.SomeError;
45	45
46	46	test "unwrap mutable global var" {
47		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
48	47	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
49	48
50	49	if (global_with_val) \|v\| {

test/behavior/math.zig-3

...	...	@@ -652,7 +652,6 @@ test "@addWithOverflow" {
652	652
653	653	test "small int addition" {
654	654	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
655		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
656	655
657	656	var x: u2 = 0;
658	657	try expect(x == 0);
...	...	@@ -1136,8 +1135,6 @@ fn testShrExact(x: u8) !void {
1136	1135	}
1137	1136
1138	1137	test "shift left/right on u0 operand" {
1139		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1140
1141	1138	const S = struct {
1142	1139	fn doTheTest() !void {
1143	1140	var x: u0 = 0;

test/behavior/pointers.zig-5

...	...	@@ -84,7 +84,6 @@ test "assigning integer to C pointer" {
84	84
85	85	test "C pointer comparison and arithmetic" {
86	86	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
87		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
88	87
89	88	const S = struct {
90	89	fn doTheTest() !void {
...	...	@@ -430,7 +429,6 @@ test "indexing array with sentinel returns correct type" {
430	429
431	430	test "element pointer to slice" {
432	431	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
433		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
434	432
435	433	const S = struct {
436	434	fn doTheTest() !void {
...	...	@@ -452,7 +450,6 @@ test "element pointer to slice" {
452	450
453	451	test "element pointer arithmetic to slice" {
454	452	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
455		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
456	453
457	454	const S = struct {
458	455	fn doTheTest() !void {
...	...	@@ -476,8 +473,6 @@ test "element pointer arithmetic to slice" {
476	473	}
477	474
478	475	test "array slicing to slice" {
479		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
480
481	476	const S = struct {
482	477	fn doTheTest() !void {
483	478	var str: [5]i32 = [_]i32{ 1, 2, 3, 4, 5 };

test/behavior/reflection.zig-1

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

test/behavior/slice.zig-5

...	...	@@ -118,7 +118,6 @@ test "slice of type" {
118	118
119	119	test "generic malloc free" {
120	120	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
121		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
122	121	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
123	122
124	123	const a = memAlloc(u8, 10) catch unreachable;
...	...	@@ -482,7 +481,6 @@ test "slice pointer-to-array null terminated" {
482	481	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
483	482	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
484	483	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
485		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
486	484
487	485	comptime {
488	486	var array = [5:0]u8{ 1, 2, 3, 4, 5 };
...	...	@@ -508,7 +506,6 @@ test "slice pointer-to-array null terminated" {
508	506	test "slice pointer-to-array zero length" {
509	507	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
510	508	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
511		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
512	509
513	510	comptime {
514	511	{
...	...	@@ -643,7 +640,6 @@ test "slicing array with sentinel as end index" {
643	640	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
644	641	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
645	642	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
646		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647	643
648	644	const S = struct {
649	645	fn do() !void {
...	...	@@ -664,7 +660,6 @@ test "slicing slice with sentinel as end index" {
664	660	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
665	661	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
666	662	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
667		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
668	663
669	664	const S = struct {
670	665	fn do() !void {

test/behavior/struct_contains_slice_of_itself.zig-2

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

test/behavior/tuple.zig-1

...	...	@@ -124,7 +124,6 @@ test "tuple initializer for var" {
124	124	test "array-like initializer for tuple types" {
125	125	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
126	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
127		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
128	127
129	128	const T = @Type(.{
130	129	.Struct = .{

test/behavior/type_info.zig-2

...	...	@@ -527,7 +527,6 @@ test "type info for async frames" {
527	527
528	528	test "Declarations are returned in declaration order" {
529	529	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
530		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
531	530	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
532	531
533	532	const S = struct {
...	...	@@ -552,7 +551,6 @@ test "Struct.is_tuple for anon list literal" {
552	551	test "Struct.is_tuple for anon struct literal" {
553	552	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
554	553	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
555		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
556	554
557	555	const info = @typeInfo(@TypeOf(.{ .a = 0 }));
558	556	try expect(!info.Struct.is_tuple);

test/behavior/union.zig-7

...	...	@@ -36,7 +36,6 @@ test "init union with runtime value - floats" {
36	36	}
37	37
38	38	test "basic unions" {
39		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
40	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
41	40
42	41	var foo = Foo{ .int = 1 };
...	...	@@ -91,7 +90,6 @@ const FooExtern = extern union {
91	90	};
92	91
93	92	test "basic extern unions" {
94		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
95	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
96	94
97	95	var foo = FooExtern{ .int = 1 };
...	...	@@ -398,7 +396,6 @@ test "tagged union with no payloads" {
398	396	}
399	397
400	398	test "union with only 1 field casted to its enum type" {
401		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
402	399	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
403	400
404	401	const Literal = union(enum) {
...	...	@@ -487,7 +484,6 @@ test "union initializer generates padding only if needed" {
487	484	}
488	485
489	486	test "runtime tag name with single field" {
490		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
491	487	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
492	488
493	489	const U = union(enum) {
...	...	@@ -540,7 +536,6 @@ const Baz = enum { A, B, C, D };
540	536
541	537	test "tagged union type" {
542	538	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
543		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
544	539	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
545	540
546	541	const foo1 = TaggedFoo{ .One = 13 };
...	...	@@ -670,7 +665,6 @@ const PartialInstWithPayload = union(enum) {
670	665	};
671	666
672	667	test "union with only 1 field casted to its enum type which has enum value specified" {
673		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
674	668	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
675	669
676	670	const Literal = union(enum) {
...	...	@@ -1110,7 +1104,6 @@ test "union enum type gets a separate scope" {
1110	1104
1111	1105	test "global variable struct contains union initialized to non-most-aligned field" {
1112	1106	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1113		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1114	1107
1115	1108	const T = struct {
1116	1109	const U = union(enum) {

test/behavior/var_args.zig-1

...	...	@@ -39,7 +39,6 @@ fn addSomeStuff(args: anytype) i32 {
39	39	}
40	40
41	41	test "runtime parameter before var args" {
42		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
43	42	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
44	43
45	44	try expect((try extraFn(10, .{})) == 0);

test/behavior/while.zig-2

...	...	@@ -256,7 +256,6 @@ fn returnWithImplicitCastFromWhileLoopTest() anyerror!void {
256	256	}
257	257
258	258	test "while on error union with else result follow else prong" {
259		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
260	259	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
261	260
262	261	const result = while (returnError()) \|value\| {
...	...	@@ -266,7 +265,6 @@ test "while on error union with else result follow else prong" {
266	265	}
267	266
268	267	test "while on error union with else result follow break prong" {
269		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
270	268	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
271	269
272	270	const result = while (returnSuccess(10)) \|value\| {

test/behavior/widening.zig-1

...	...	@@ -30,7 +30,6 @@ test "integer widening u0 to u8" {
30	30	test "implicit unsigned integer to signed integer" {
31	31	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
32	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
33		if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
34	33	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
35	34
36	35	var a: u8 = 250;