Commit 22895f5616c663bb7b8ad9866c29d00bc4bc315c | zig

author	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-02-14 22:33:01+01:00
committer	Joachim Schmidt <joachim.schmidt557@outlook.com> 2022-02-14 22:33:01+01:00
log	22895f5616c663bb7b8ad9866c29d00bc4bc315c
tree	d0bec94aacb933d99b54e469317a1160f8c08ffe
parent	98c71cc88a2d472dded057a4a6f1d610dad9e491
signature	Commit is signed but in an unrecognized format.

stage2 AArch64: Enable behavior testing

28 files changed, 226 insertions(+), 5 deletions(-)

src/arch/aarch64/CodeGen.zig+30-4

...	...	@@ -1029,14 +1029,16 @@ fn binOpRegister(
1029	1029	if (!rhs_is_register) try self.genSetReg(rhs_ty, rhs_reg, rhs);
1030	1030
1031	1031	const mir_tag: Mir.Inst.Tag = switch (tag) {
1032		.add => .add_shifted_register,
1033		.sub => .sub_shifted_register,
	1032	.add, .ptr_add => .add_shifted_register,
	1033	.sub, .ptr_sub => .sub_shifted_register,
1034	1034	.xor => .eor_shifted_register,
1035	1035	else => unreachable,
1036	1036	};
1037	1037	const mir_data: Mir.Inst.Data = switch (tag) {
1038	1038	.add,
1039	1039	.sub,
	1040	.ptr_add,
	1041	.ptr_sub,
1040	1042	=> .{ .rrr_imm6_shift = .{
1041	1043	.rd = dest_reg,
1042	1044	.rn = lhs_reg,
...	...	@@ -1225,7 +1227,24 @@ fn binOp(
1225	1227	},
1226	1228	.ptr_add,
1227	1229	.ptr_sub,
1228		=> return self.fail("TODO ptr_add, ptr_sub", .{}),
	1230	=> {
	1231	switch (lhs_ty.zigTypeTag()) {
	1232	.Pointer => {
	1233	const ptr_ty = lhs_ty;
	1234	const pointee_ty = switch (ptr_ty.ptrSize()) {
	1235	.One => ptr_ty.childType().childType(), // ptr to array, so get array element type
	1236	else => ptr_ty.childType(),
	1237	};
	1238
	1239	if (pointee_ty.abiSize(self.target.*) > 1) {
	1240	return self.fail("TODO ptr_add, ptr_sub with more element sizes", .{});
	1241	}
	1242
	1243	return try self.binOpRegister(tag, maybe_inst, lhs, rhs, lhs_ty, rhs_ty);
	1244	},
	1245	else => unreachable,
	1246	}
	1247	},
1229	1248	else => unreachable,
1230	1249	}
1231	1250	}
...	...	@@ -1439,7 +1458,14 @@ fn airWrapErrUnionPayload(self: *Self, inst: Air.Inst.Index) !void {
1439	1458	/// E to E!T
1440	1459	fn airWrapErrUnionErr(self: *Self, inst: Air.Inst.Index) !void {
1441	1460	const ty_op = self.air.instructions.items(.data)[inst].ty_op;
1442		const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement wrap errunion error for {}", .{self.target.cpu.arch});
	1461	const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
	1462	const error_union_ty = self.air.getRefType(ty_op.ty);
	1463	const payload_ty = error_union_ty.errorUnionPayload();
	1464	const mcv = try self.resolveInst(ty_op.operand);
	1465	if (!payload_ty.hasRuntimeBits()) break :result mcv;
	1466
	1467	return self.fail("TODO implement wrap errunion error for non-empty payloads", .{});
	1468	};
1443	1469	return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
1444	1470	}
1445	1471

test/behavior.zig+1-1

...	...	@@ -54,7 +54,7 @@ test {
54	54	_ = @import("behavior/decltest.zig");
55	55	}
56	56
57		if (builtin.zig_backend != .stage2_arm and builtin.zig_backend != .stage2_x86_64) {
	57	if (builtin.zig_backend != .stage2_arm and builtin.zig_backend != .stage2_x86_64 and builtin.zig_backend != .stage2_aarch64) {
58	58	// Tests that pass (partly) for stage1, llvm backend, C backend, wasm backend.
59	59	_ = @import("behavior/bitcast.zig");
60	60	_ = @import("behavior/bugs/624.zig");

test/behavior/align.zig+18

...	...	@@ -27,6 +27,7 @@ test "default alignment allows unspecified in type syntax" {
27	27	}
28	28
29	29	test "implicitly decreasing pointer alignment" {
	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	31	const a: u32 align(4) = 3;
31	32	const b: u32 align(8) = 4;
32	33	try expect(addUnaligned(&a, &b) == 7);
...	...	@@ -37,6 +38,7 @@ fn addUnaligned(a: align(1) const u32, b: align(1) const u32) u32 {
37	38	}
38	39
39	40	test "@alignCast pointers" {
	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
40	42	var x: u32 align(4) = 1;
41	43	expectsOnly1(&x);
42	44	try expect(x == 2);
...	...	@@ -102,6 +104,7 @@ fn fnWithAlignedStack() i32 {
102	104	}
103	105
104	106	test "implicitly decreasing slice alignment" {
	107	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
105	108	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
106	109
107	110	const a: u32 align(4) = 3;
...	...	@@ -113,6 +116,7 @@ fn addUnalignedSlice(a: []align(1) const u32, b: []align(1) const u32) u32 {
113	116	}
114	117
115	118	test "specifying alignment allows pointer cast" {
	119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
116	120	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
117	121
118	122	try testBytesAlign(0x33);
...	...	@@ -124,6 +128,7 @@ fn testBytesAlign(b: u8) !void {
124	128	}
125	129
126	130	test "@alignCast slices" {
	131	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127	132	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128	133
129	134	var array align(4) = [_]u32{ 1, 1 };
...	...	@@ -139,6 +144,7 @@ fn sliceExpects4(slice: []align(4) u32) void {
139	144	}
140	145
141	146	test "return error union with 128-bit integer" {
	147	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
142	148	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
143	149
144	150	try expect(3 == try give());
...	...	@@ -148,6 +154,7 @@ fn give() anyerror!u128 {
148	154	}
149	155
150	156	test "page aligned array on stack" {
	157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
151	158	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
152	159	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
153	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
...	...	@@ -173,6 +180,7 @@ fn noop1() align(1) void {}
173	180	fn noop4() align(4) void {}
174	181
175	182	test "function alignment" {
	183	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
176	184	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
177	185	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
178	186	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
...	...	@@ -189,6 +197,7 @@ test "function alignment" {
189	197	}
190	198
191	199	test "implicitly decreasing fn alignment" {
	200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	201	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
193	202	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
194	203	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
...	...	@@ -216,6 +225,7 @@ fn alignedBig() align(16) i32 {
216	225	}
217	226
218	227	test "@alignCast functions" {
	228	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
219	229	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
220	230	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
221	231	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
...	...	@@ -239,6 +249,7 @@ fn simple4() align(4) i32 {
239	249	}
240	250
241	251	test "generic function with align param" {
	252	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
242	253	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
243	254	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
244	255	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
...	...	@@ -260,6 +271,7 @@ fn whyWouldYouEverDoThis(comptime align_bytes: u8) align(align_bytes) u8 {
260	271	}
261	272
262	273	test "runtime known array index has best alignment possible" {
	274	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
263	275	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
264	276	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
265	277	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
...	...	@@ -302,6 +314,7 @@ fn testIndex2(ptr: [*]align(4) u8, index: usize, comptime T: type) !void {
302	314	}
303	315
304	316	test "alignment of function with c calling convention" {
	317	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
305	318	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
306	319
307	320	var runtime_nothing = &nothing;
...	...	@@ -318,6 +331,7 @@ const DefaultAligned = struct {
318	331	};
319	332
320	333	test "read 128-bit field from default aligned struct in stack memory" {
	334	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
321	335	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
322	336	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
323	337	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
...	...	@@ -337,6 +351,7 @@ var default_aligned_global = DefaultAligned{
337	351	};
338	352
339	353	test "read 128-bit field from default aligned struct in global memory" {
	354	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
340	355	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
341	356	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
342	357	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
...	...	@@ -348,6 +363,7 @@ test "read 128-bit field from default aligned struct in global memory" {
348	363	}
349	364
350	365	test "struct field explicit alignment" {
	366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
351	367	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
352	368	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
353	369	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
...	...	@@ -369,6 +385,7 @@ test "struct field explicit alignment" {
369	385	}
370	386
371	387	test "align(@alignOf(T)) T does not force resolution of T" {
	388	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
372	389	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
373	390	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
374	391	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
...	...	@@ -397,6 +414,7 @@ test "align(@alignOf(T)) T does not force resolution of T" {
397	414	}
398	415
399	416	test "align(N) on functions" {
	417	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
400	418	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
401	419	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest;
402	420	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

test/behavior/alignof.zig+1

...	...	@@ -11,6 +11,7 @@ const Foo = struct {
11	11	};
12	12
13	13	test "@alignOf(T) before referencing T" {
	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14	15	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

test/behavior/array.zig+27

...	...	@@ -6,6 +6,7 @@ const expect = testing.expect;
6	6	const expectEqual = testing.expectEqual;
7	7
8	8	test "array to slice" {
	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	10	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10	11
11	12	const a: u32 align(4) = 3;
...	...	@@ -20,6 +21,7 @@ test "array to slice" {
20	21	}
21	22
22	23	test "arrays" {
	24	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
23	25	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
24	26
25	27	var array: [5]u32 = undefined;
...	...	@@ -46,6 +48,7 @@ fn getArrayLen(a: []const u32) usize {
46	48	}
47	49
48	50	test "array init with mult" {
	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
49	52	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
50	53
51	54	const a = 'a';
...	...	@@ -57,6 +60,7 @@ test "array init with mult" {
57	60	}
58	61
59	62	test "array literal with explicit type" {
	63	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
60	64	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
61	65
62	66	const hex_mult: [4]u16 = .{ 4096, 256, 16, 1 };
...	...	@@ -86,6 +90,7 @@ const ArrayDotLenConstExpr = struct {
86	90	const some_array = [_]u8{ 0, 1, 2, 3 };
87	91
88	92	test "array literal with specified size" {
	93	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
89	94	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
90	95
91	96	var array = [2]u8{ 1, 2 };
...	...	@@ -94,6 +99,7 @@ test "array literal with specified size" {
94	99	}
95	100
96	101	test "array len field" {
	102	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
97	103	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98	104
99	105	var arr = [4]u8{ 0, 0, 0, 0 };
...	...	@@ -105,6 +111,7 @@ test "array len field" {
105	111	}
106	112
107	113	test "array with sentinels" {
	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
108	115	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109	116
110	117	const S = struct {
...	...	@@ -134,6 +141,7 @@ test "array with sentinels" {
134	141	}
135	142
136	143	test "void arrays" {
	144	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
137	145	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
138	146
139	147	var array: [4]void = undefined;
...	...	@@ -144,6 +152,7 @@ test "void arrays" {
144	152	}
145	153
146	154	test "nested arrays" {
	155	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
147	156	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
148	157
149	158	const array_of_strings = [_][]const u8{ "hello", "this", "is", "my", "thing" };
...	...	@@ -157,6 +166,7 @@ test "nested arrays" {
157	166	}
158	167
159	168	test "implicit comptime in array type size" {
	169	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
160	170	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161	171
162	172	var arr: [plusOne(10)]bool = undefined;
...	...	@@ -168,6 +178,7 @@ fn plusOne(x: u32) u32 {
168	178	}
169	179
170	180	test "single-item pointer to array indexing and slicing" {
	181	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
171	182	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
172	183
173	184	try testSingleItemPtrArrayIndexSlice();
...	...	@@ -193,6 +204,7 @@ fn doSomeMangling(array: *[4]u8) void {
193	204	}
194	205
195	206	test "implicit cast zero sized array ptr to slice" {
	207	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
196	208	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
197	209
198	210	{
...	...	@@ -208,6 +220,7 @@ test "implicit cast zero sized array ptr to slice" {
208	220	}
209	221
210	222	test "anonymous list literal syntax" {
	223	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
211	224	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
212	225
213	226	const S = struct {
...	...	@@ -227,6 +240,7 @@ var s_array: [8]Sub = undefined;
227	240	const Sub = struct { b: u8 };
228	241	const Str = struct { a: []Sub };
229	242	test "set global var array via slice embedded in struct" {
	243	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
230	244	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
231	245	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
232	246	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -243,6 +257,7 @@ test "set global var array via slice embedded in struct" {
243	257	}
244	258
245	259	test "read/write through global variable array of struct fields initialized via array mult" {
	260	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
246	261	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
247	262	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
248	263	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -264,6 +279,7 @@ test "read/write through global variable array of struct fields initialized via
264	279	}
265	280
266	281	test "implicit cast single-item pointer" {
	282	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
267	283	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
268	284	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
269	285	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -284,6 +300,7 @@ fn testArrayByValAtComptime(b: [2]u8) u8 {
284	300	}
285	301
286	302	test "comptime evaluating function that takes array by value" {
	303	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
287	304	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
288	305	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
289	306	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -296,6 +313,7 @@ test "comptime evaluating function that takes array by value" {
296	313	}
297	314
298	315	test "runtime initialize array elem and then implicit cast to slice" {
	316	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
299	317	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
300	318	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
301	319	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -306,6 +324,7 @@ test "runtime initialize array elem and then implicit cast to slice" {
306	324	}
307	325
308	326	test "array literal as argument to function" {
	327	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
309	328	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
310	329	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
311	330	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -334,6 +353,7 @@ test "array literal as argument to function" {
334	353	}
335	354
336	355	test "double nested array to const slice cast in array literal" {
	356	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
337	357	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
338	358	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
339	359	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -395,6 +415,7 @@ test "double nested array to const slice cast in array literal" {
395	415	}
396	416
397	417	test "anonymous literal in array" {
	418	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
398	419	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
399	420	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
400	421	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -420,6 +441,7 @@ test "anonymous literal in array" {
420	441	}
421	442
422	443	test "access the null element of a null terminated array" {
	444	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
423	445	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
424	446	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
425	447	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -437,6 +459,7 @@ test "access the null element of a null terminated array" {
437	459	}
438	460
439	461	test "type deduction for array subscript expression" {
	462	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
440	463	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
441	464	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
442	465	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -455,6 +478,7 @@ test "type deduction for array subscript expression" {
455	478	}
456	479
457	480	test "sentinel element count towards the ABI size calculation" {
	481	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
458	482	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
459	483	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
460	484	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -481,6 +505,7 @@ test "sentinel element count towards the ABI size calculation" {
481	505	}
482	506
483	507	test "zero-sized array with recursive type definition" {
	508	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
484	509	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
485	510	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
486	511	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -505,6 +530,7 @@ test "zero-sized array with recursive type definition" {
505	530	}
506	531
507	532	test "type coercion of anon struct literal to array" {
	533	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
508	534	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
509	535	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
510	536	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -540,6 +566,7 @@ test "type coercion of anon struct literal to array" {
540	566	}
541	567
542	568	test "type coercion of pointer to anon struct literal to pointer to array" {
	569	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
543	570	if (builtin.zig_backend == .stage2_llvm) return error.SkipZigTest; // TODO
544	571	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
545	572	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

test/behavior/basic.zig+32

...	...	@@ -15,6 +15,7 @@ test "empty function with comments" {
15	15	}
16	16
17	17	test "truncate" {
	18	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
18	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	20
20	21	try expect(testTruncate(0x10fd) == 0xfd);
...	...	@@ -25,6 +26,7 @@ fn testTruncate(x: u32) u8 {
25	26	}
26	27
27	28	test "truncate to non-power-of-two integers" {
	29	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
28	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
29	31
30	32	try testTrunc(u32, u1, 0b10101, 0b1);
...	...	@@ -46,6 +48,7 @@ const g1: i32 = 1233 + 1;
46	48	var g2: i32 = 0;
47	49
48	50	test "global variables" {
	51	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
49	52	try expect(g2 == 0);
50	53	g2 = g1;
51	54	try expect(g2 == 1234);
...	...	@@ -112,6 +115,7 @@ fn first4KeysOfHomeRow() []const u8 {
112	115	}
113	116
114	117	test "return string from function" {
	118	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
115	119	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116	120	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
117	121
...	...	@@ -119,12 +123,14 @@ test "return string from function" {
119	123	}
120	124
121	125	test "hex escape" {
	126	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
122	127	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
123	128
124	129	try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
125	130	}
126	131
127	132	test "multiline string" {
	133	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
128	134	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
129	135
130	136	const s1 =
...	...	@@ -137,6 +143,7 @@ test "multiline string" {
137	143	}
138	144
139	145	test "multiline string comments at start" {
	146	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
140	147	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
141	148
142	149	const s1 =
...	...	@@ -149,6 +156,7 @@ test "multiline string comments at start" {
149	156	}
150	157
151	158	test "multiline string comments at end" {
	159	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
152	160	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
153	161
154	162	const s1 =
...	...	@@ -161,6 +169,7 @@ test "multiline string comments at end" {
161	169	}
162	170
163	171	test "multiline string comments in middle" {
	172	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
164	173	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
165	174
166	175	const s1 =
...	...	@@ -173,6 +182,7 @@ test "multiline string comments in middle" {
173	182	}
174	183
175	184	test "multiline string comments at multiple places" {
	185	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
176	186	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
177	187
178	188	const s1 =
...	...	@@ -191,6 +201,7 @@ test "string concatenation" {
191	201	}
192	202
193	203	test "array mult operator" {
	204	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
194	205	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
195	206
196	207	try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
...	...	@@ -216,6 +227,7 @@ test "compile time global reinterpret" {
216	227	}
217	228
218	229	test "cast undefined" {
	230	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
219	231	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220	232
221	233	const array: [100]u8 = undefined;
...	...	@@ -227,6 +239,7 @@ fn testCastUndefined(x: []const u8) void {
227	239	}
228	240
229	241	test "implicit cast after unreachable" {
	242	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
230	243	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
231	244
232	245	try expect(outer() == 1234);
...	...	@@ -284,6 +297,7 @@ fn fB() []const u8 {
284	297	}
285	298
286	299	test "call function pointer in struct" {
	300	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
287	301	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
288	302	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
289	303
...	...	@@ -310,6 +324,7 @@ const FnPtrWrapper = struct {
310	324	};
311	325
312	326	test "const ptr from var variable" {
	327	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
313	328	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
314	329
315	330	var x: u64 = undefined;
...	...	@@ -326,6 +341,7 @@ fn copy(src: const u64, dst: u64) void {
326	341	}
327	342
328	343	test "call result of if else expression" {
	344	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
329	345	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
330	346	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
331	347	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -339,6 +355,7 @@ fn f2(x: bool) []const u8 {
339	355	}
340	356
341	357	test "memcpy and memset intrinsics" {
	358	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
342	359	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
343	360	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
344	361	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
...	...	@@ -361,6 +378,7 @@ fn testMemcpyMemset() !void {
361	378	}
362	379
363	380	test "variable is allowed to be a pointer to an opaque type" {
	381	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
364	382	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
365	383	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
366	384	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -374,6 +392,7 @@ fn hereIsAnOpaqueType(ptr: OpaqueA) OpaqueA {
374	392	}
375	393
376	394	test "take address of parameter" {
	395	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
377	396	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
378	397	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
379	398
...	...	@@ -400,6 +419,7 @@ fn testPointerToVoidReturnType2() *const void {
400	419	}
401	420
402	421	test "array 2D const double ptr" {
	422	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
403	423	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
404	424	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
405	425
...	...	@@ -419,6 +439,7 @@ fn testArray2DConstDoublePtr(ptr: *const f32) !void {
419	439	}
420	440
421	441	test "double implicit cast in same expression" {
	442	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
422	443	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
423	444	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
424	445
...	...	@@ -430,6 +451,7 @@ fn nine() u8 {
430	451	}
431	452
432	453	test "struct inside function" {
	454	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
433	455	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
434	456
435	457	try testStructInFn();
...	...	@@ -451,6 +473,7 @@ fn testStructInFn() !void {
451	473	}
452	474
453	475	test "fn call returning scalar optional in equality expression" {
	476	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
454	477	try expect(getNull() == null);
455	478	}
456	479
...	...	@@ -459,6 +482,7 @@ fn getNull() ?*i32 {
459	482	}
460	483
461	484	test "global variable assignment with optional unwrapping with var initialized to undefined" {
	485	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
462	486	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
463	487
464	488	const S = struct {
...	...	@@ -476,6 +500,7 @@ test "global variable assignment with optional unwrapping with var initialized t
476	500	var global_foo: *i32 = undefined;
477	501
478	502	test "peer result location with typed parent, runtime condition, comptime prongs" {
	503	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
479	504	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
480	505	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
481	506
...	...	@@ -550,6 +575,7 @@ test "comptime cast fn to ptr" {
550	575	}
551	576
552	577	test "equality compare fn ptrs" {
	578	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
553	579	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
554	580
555	581	var a = &emptyFn;
...	...	@@ -557,6 +583,7 @@ test "equality compare fn ptrs" {
557	583	}
558	584
559	585	test "self reference through fn ptr field" {
	586	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
560	587	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
561	588	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
562	589
...	...	@@ -576,6 +603,7 @@ test "self reference through fn ptr field" {
576	603	}
577	604
578	605	test "global variable initialized to global variable array element" {
	606	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
579	607	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
580	608	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
581	609
...	...	@@ -593,6 +621,7 @@ var gdt = [_]GDTEntry{
593	621	var global_ptr = &gdt[0];
594	622
595	623	test "global constant is loaded with a runtime-known index" {
	624	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
596	625	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
597	626
598	627	const S = struct {
...	...	@@ -610,6 +639,7 @@ test "global constant is loaded with a runtime-known index" {
610	639	}
611	640
612	641	test "multiline string literal is null terminated" {
	642	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
613	643	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
614	644	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
615	645
...	...	@@ -643,6 +673,7 @@ test "explicit cast optional pointers" {
643	673	}
644	674
645	675	test "pointer comparison" {
	676	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
646	677	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
647	678	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
648	679
...	...	@@ -655,6 +686,7 @@ fn ptrEql(a: const []const u8, b: const []const u8) bool {
655	686	}
656	687
657	688	test "string concatenation" {
	689	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
658	690	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
659	691	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
660	692

test/behavior/bit_shifting.zig+1

...	...	@@ -61,6 +61,7 @@ fn ShardedTable(comptime Key: type, comptime mask_bit_count: comptime_int, compt
61	61	}
62	62
63	63	test "sharded table" {
	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
64	65	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
65	66	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
66	67	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

test/behavior/bugs/1381.zig+1

...	...	@@ -12,6 +12,7 @@ const A = union(enum) {
12	12	};
13	13
14	14	test "union that needs padding bytes inside an array" {
	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
17	18	var as = [_]A{

test/behavior/bugs/1486.zig+2

...	...	@@ -1,10 +1,12 @@
1	1	const std = @import("std");
2	2	const expect = std.testing.expect;
	3	const builtin = @import("builtin");
3	4
4	5	const ptr = &global;
5	6	var global: usize = 123;
6	7
7	8	test "constant pointer to global variable causes runtime load" {
	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	10	global = 1234;
9	11	try expect(&global == ptr);
10	12	try expect(ptr.* == 1234);

test/behavior/bugs/1735.zig+1

...	...	@@ -42,6 +42,7 @@ const a = struct {
42	42	};
43	43
44	44	test "initialization" {
	45	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
45	46	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
46	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
47	48	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

test/behavior/bugs/1741.zig+1

...	...	@@ -2,6 +2,7 @@ const std = @import("std");
2	2	const builtin = @import("builtin");
3	3
4	4	test "fixed" {
	5	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
5	6	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
6	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7	8	const x: f32 align(128) = 12.34;

test/behavior/bugs/2006.zig+1

...	...	@@ -6,6 +6,7 @@ const S = struct {
6	6	p: *S,
7	7	};
8	8	test "bug 2006" {
	9	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9	10	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
10	11	var a: S = undefined;
11	12	a = S{ .p = undefined };

test/behavior/bugs/2578.zig+1

...	...	@@ -12,6 +12,7 @@ fn bar(pointer: ?*anyopaque) void {
12	12	}
13	13
14	14	test "fixed" {
	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
16	17	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
17	18	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

test/behavior/bugs/3007.zig+1

...	...	@@ -19,6 +19,7 @@ fn get_foo() Foo.FooError!*Foo {
19	19	}
20	20
21	21	test "fixed" {
	22	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
22	23	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
23	24	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
24	25	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO

test/behavior/bugs/3112.zig+1

...	...	@@ -12,6 +12,7 @@ fn prev(p: ?State) void {
12	12	}
13	13
14	14	test "zig test crash" {
	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
15	16	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
16	17	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
17	18	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;

test/behavior/bugs/3367.zig+1

...	...	@@ -10,6 +10,7 @@ const Mixin = struct {
10	10	};
11	11
12	12	test "container member access usingnamespace decls" {
	13	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
13	14	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
14	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	16	var foo = Foo{};

test/behavior/bugs/394.zig+1

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

test/behavior/bugs/656.zig+1

...	...	@@ -11,6 +11,7 @@ const Value = struct {
11	11	};
12	12
13	13	test "optional if after an if in a switch prong of a switch with 2 prongs in an else" {
	14	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14	15	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	16	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
16	17	try foo(false, true);

test/behavior/bugs/7250.zig+1

...	...	@@ -14,6 +14,7 @@ threadlocal var g_uart0 = nrfx_uart_t{
14	14	};
15	15
16	16	test "reference a global threadlocal variable" {
	17	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
17	18	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
18	19	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
19	20	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

test/behavior/cast.zig+36

...	...	@@ -18,6 +18,7 @@ test "integer literal to pointer cast" {
18	18	}
19	19
20	20	test "peer type resolution: ?T and T" {
	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	22	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
22	23
23	24	try expect(peerTypeTAndOptionalT(true, false).? == 0);
...	...	@@ -94,6 +95,7 @@ test "comptime_int @intToFloat" {
94	95	}
95	96
96	97	test "@floatToInt" {
	98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
97	99	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
98	100	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
99	101
...	...	@@ -116,6 +118,7 @@ fn expectFloatToInt(comptime F: type, f: F, comptime I: type, i: I) !void {
116	118	}
117	119
118	120	test "implicitly cast indirect pointer to maybe-indirect pointer" {
	121	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
119	122	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
120	123
121	124	const S = struct {
...	...	@@ -174,6 +177,7 @@ test "@floatCast comptime_int and comptime_float" {
174	177	}
175	178
176	179	test "coerce undefined to optional" {
	180	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
177	181	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
178	182
179	183	try expect(MakeType(void).getNull() == null);
...	...	@@ -193,6 +197,7 @@ fn MakeType(comptime T: type) type {
193	197	}
194	198
195	199	test "implicit cast from [N]T to [c]T" {
	200	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
196	201	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
197	202
198	203	var x: [4]u16 = [4]u16{ 0, 1, 2, 3 };
...	...	@@ -205,6 +210,7 @@ test "implicit cast from [N]T to [c]T" {
205	210	}
206	211
207	212	test "usize to void" {
	213	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
208	214	var i = @as(usize, 0);
209	215	var v = @ptrCast(*void, &i);
210	216	v.* = {};
...	...	@@ -230,6 +236,7 @@ test "@intCast to u0 and use the result" {
230	236	}
231	237
232	238	test "peer result null and comptime_int" {
	239	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
233	240	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
234	241
235	242	const S = struct {
...	...	@@ -253,6 +260,7 @@ test "peer result null and comptime_int" {
253	260	}
254	261
255	262	test "const ?[]const T to [c]const [c]const T" {
	263	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
256	264	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
257	265
258	266	var array = [_]u8{ 'o', 'k' };
...	...	@@ -264,6 +272,7 @@ test "const ?[]const T to [c]const [c]const T" {
264	272	}
265	273
266	274	test "array coersion to undefined at runtime" {
	275	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
267	276	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
268	277
269	278	@setRuntimeSafety(true);
...	...	@@ -293,6 +302,7 @@ fn implicitIntLitToOptional() void {
293	302	}
294	303
295	304	test "return u8 coercing into ?u32 return type" {
	305	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
296	306	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
297	307
298	308	const S = struct {
...	...	@@ -313,6 +323,7 @@ test "cast from ?[]T to ??[]T" {
313	323	}
314	324
315	325	test "peer type unsigned int to signed" {
	326	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
316	327	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
317	328	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
318	329
...	...	@@ -325,6 +336,7 @@ test "peer type unsigned int to signed" {
325	336	}
326	337
327	338	test "expected [c]const u8, found [:0]const u8" {
	339	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
328	340	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
329	341	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
330	342
...	...	@@ -384,6 +396,7 @@ fn castToOptionalTypeError(z: i32) !void {
384	396	}
385	397
386	398	test "implicitly cast from [0]T to anyerror![]T" {
	399	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
387	400	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
388	401	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
389	402	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -455,6 +468,7 @@ fn testCastConstArrayRefToConstSlice() !void {
455	468	}
456	469
457	470	test "peer type resolution: error and [N]T" {
	471	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
458	472	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
459	473	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
460	474
...	...	@@ -689,6 +703,7 @@ test "type coercion related to sentinel-termination" {
689	703	}
690	704
691	705	test "peer type resolution implicit cast to return type" {
	706	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
692	707	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
693	708	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
694	709	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -710,6 +725,7 @@ test "peer type resolution implicit cast to return type" {
710	725	}
711	726
712	727	test "peer type resolution implicit cast to variable type" {
	728	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
713	729	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
714	730	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
715	731	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -806,6 +822,7 @@ test "comptime float casts" {
806	822	}
807	823
808	824	test "pointer reinterpret const float to int" {
	825	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
809	826	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
810	827	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
811	828	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -822,6 +839,7 @@ test "pointer reinterpret const float to int" {
822	839	}
823	840
824	841	test "implicit cast from []T to ?anyopaque" {
	842	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
825	843	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
826	844	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
827	845	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -840,6 +858,7 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
840	858	}
841	859
842	860	test "compile time int to ptr of function" {
	861	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
843	862	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
844	863	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .aarch64) return error.SkipZigTest; // TODO
845	864	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -857,6 +876,7 @@ fn foobar(func: PFN_void) !void {
857	876	}
858	877
859	878	test "implicit ptr to *anyopaque" {
	879	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
860	880	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
861	881	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
862	882	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -871,6 +891,7 @@ test "implicit ptr to *anyopaque" {
871	891	}
872	892
873	893	test "return null from fn() anyerror!?&T" {
	894	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
874	895	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
875	896	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
876	897
...	...	@@ -887,6 +908,7 @@ fn returnNullLitFromOptionalTypeErrorRef() anyerror!?*A {
887	908	}
888	909
889	910	test "peer type resolution: [0]u8 and []const u8" {
	911	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
890	912	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
891	913	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
892	914	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -907,6 +929,7 @@ fn peerTypeEmptyArrayAndSlice(a: bool, slice: []const u8) []const u8 {
907	929	}
908	930
909	931	test "implicitly cast from [N]T to ?[]const T" {
	932	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
910	933	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
911	934	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
912	935	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -920,6 +943,7 @@ fn castToOptionalSlice() ?[]const u8 {
920	943	}
921	944
922	945	test "cast u128 to f128 and back" {
	946	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
923	947	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
924	948	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
925	949	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -941,6 +965,7 @@ fn cast128Float(x: u128) f128 {
941	965	}
942	966
943	967	test "implicit cast from [N]T to ?[]T" {
	968	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
944	969	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
945	970	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
946	971	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -956,6 +981,7 @@ test "implicit cast from [N]T to ?[]T" {
956	981	}
957	982
958	983	test "implicit cast from T to ?anyopaque" {
	984	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
959	985	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
960	986	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
961	987	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -970,6 +996,7 @@ fn incrementVoidPtrValue(value: ?*anyopaque) void {
970	996	}
971	997
972	998	test "implicit cast *[0]T to E![]const u8" {
	999	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
973	1000	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
974	1001	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
975	1002	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -987,6 +1014,7 @@ test "cast from array reference to fn: comptime fn ptr" {
987	1014	try expect(@ptrToInt(f) == @ptrToInt(&global_array));
988	1015	}
989	1016	test "cast from array reference to fn: runtime fn ptr" {
	1017	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
990	1018	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
991	1019	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
992	1020	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -996,6 +1024,7 @@ test "cast from array reference to fn: runtime fn ptr" {
996	1024	}
997	1025
998	1026	test "*const [N]null u8 to ?[]const u8" {
	1027	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
999	1028	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1000	1029	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1001	1030	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -1034,6 +1063,7 @@ test "cast between [c]T and ?[:0]T on fn parameter" {
1034	1063
1035	1064	var global_struct: struct { f0: usize } = undefined;
1036	1065	test "assignment to optional pointer result loc" {
	1066	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1037	1067	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1038	1068	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1039	1069	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -1043,6 +1073,7 @@ test "assignment to optional pointer result loc" {
1043	1073	}
1044	1074
1045	1075	test "cast between *[N]void and []void" {
	1076	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1046	1077	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1047	1078	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1048	1079
...	...	@@ -1052,6 +1083,7 @@ test "cast between *[N]void and []void" {
1052	1083	}
1053	1084
1054	1085	test "peer resolve arrays of different size to const slice" {
	1086	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1055	1087	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1056	1088	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1057	1089
...	...	@@ -1065,6 +1097,7 @@ fn boolToStr(b: bool) []const u8 {
1065	1097	}
1066	1098
1067	1099	test "cast f16 to wider types" {
	1100	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1068	1101	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1069	1102	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1070	1103	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -1083,6 +1116,7 @@ test "cast f16 to wider types" {
1083	1116	}
1084	1117
1085	1118	test "cast f128 to narrower types" {
	1119	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1086	1120	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1087	1121	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1088	1122	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -1101,6 +1135,7 @@ test "cast f128 to narrower types" {
1101	1135	}
1102	1136
1103	1137	test "peer type resolution: unreachable, null, slice" {
	1138	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1104	1139	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1105	1140	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1106	1141	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
...	...	@@ -1119,6 +1154,7 @@ test "peer type resolution: unreachable, null, slice" {
1119	1154	}
1120	1155
1121	1156	test "cast i8 fn call peers to i32 result" {
	1157	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1122	1158	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
1123	1159	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
1124	1160

test/behavior/fn_delegation.zig+1

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

test/behavior/ir_block_deps.zig+1

...	...	@@ -18,6 +18,7 @@ fn getErrInt() anyerror!i32 {
18	18	}
19	19
20	20	test "ir block deps" {
	21	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	22	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
22	23	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
23	24

test/behavior/optional.zig+10

...	...	@@ -5,6 +5,7 @@ const expect = testing.expect;
5	5	const expectEqual = testing.expectEqual;
6	6
7	7	test "passing an optional integer as a parameter" {
	8	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8	9	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
9	10	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10	11
...	...	@@ -25,6 +26,7 @@ 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_aarch64) return error.SkipZigTest;
28	30	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
29	31	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
30	32
...	...	@@ -34,6 +36,7 @@ test "optional pointer to size zero struct" {
34	36	}
35	37
36	38	test "equality compare optional pointers" {
	39	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
37	40	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
38	41	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
39	42
...	...	@@ -58,6 +61,7 @@ fn testNullPtrsEql() !void {
58	61	}
59	62
60	63	test "optional with void type" {
	64	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
61	65	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
62	66	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
63	67
...	...	@@ -69,6 +73,7 @@ test "optional with void type" {
69	73	}
70	74
71	75	test "address of unwrap optional" {
	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
72	77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
73	78	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
74	79
...	...	@@ -89,6 +94,7 @@ test "address of unwrap optional" {
89	94	}
90	95
91	96	test "nested optional field in struct" {
	97	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
92	98	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
93	99	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
94	100
...	...	@@ -105,6 +111,7 @@ test "nested optional field in struct" {
105	111	}
106	112
107	113	test "equality compare optional with non-optional" {
	114	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
108	115	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
109	116	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
110	117
...	...	@@ -142,6 +149,7 @@ fn test_cmp_optional_non_optional() !void {
142	149	}
143	150
144	151	test "unwrap function call with optional pointer return value" {
	152	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
145	153	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
146	154	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
147	155
...	...	@@ -163,6 +171,7 @@ test "unwrap function call with optional pointer return value" {
163	171	}
164	172
165	173	test "nested orelse" {
	174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
166	175	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
167	176	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
168	177
...	...	@@ -189,6 +198,7 @@ test "nested orelse" {
189	198	}
190	199
191	200	test "self-referential struct through a slice of optional" {
	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	202	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
193	203	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
194	204	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO

test/behavior/reflection.zig+1

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

test/behavior/slice.zig+14

...	...	@@ -27,6 +27,7 @@ comptime {
27	27	}
28	28
29	29	test "slicing" {
	30	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
30	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
31	32	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
32	33	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -68,6 +69,7 @@ test "comptime slice of undefined pointer of length 0" {
68	69	}
69	70
70	71	test "implicitly cast array of size 0 to slice" {
	72	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
71	73	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
72	74	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
73	75
...	...	@@ -80,6 +82,7 @@ fn assertLenIsZero(msg: []const u8) !void {
80	82	}
81	83
82	84	test "access len index of sentinel-terminated slice" {
	85	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
83	86	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
84	87
85	88	const S = struct {
...	...	@@ -129,6 +132,7 @@ test "slice of type" {
129	132	}
130	133
131	134	test "generic malloc free" {
	135	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
132	136	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
133	137	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
134	138	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
...	...	@@ -187,6 +191,7 @@ test "comptime pointer cast array and then slice" {
187	191	}
188	192
189	193	test "slicing zero length array" {
	194	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
190	195	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
191	196	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
192	197	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
...	...	@@ -202,6 +207,7 @@ test "slicing zero length array" {
202	207	const x = @intToPtr([*]i32, 0x1000)[0..0x500];
203	208	const y = x[0x100..];
204	209	test "compile time slice of pointer to hard coded address" {
	210	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
205	211	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
206	212	if (builtin.zig_backend == .stage1) return error.SkipZigTest;
207	213	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
...	...	@@ -215,6 +221,7 @@ test "compile time slice of pointer to hard coded address" {
215	221	}
216	222
217	223	test "slice string literal has correct type" {
	224	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
218	225	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
219	226	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
220	227
...	...	@@ -230,6 +237,7 @@ test "slice string literal has correct type" {
230	237	}
231	238
232	239	test "result location zero sized array inside struct field implicit cast to slice" {
	240	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
233	241	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
234	242
235	243	const E = struct {
...	...	@@ -240,6 +248,7 @@ test "result location zero sized array inside struct field implicit cast to slic
240	248	}
241	249
242	250	test "runtime safety lets us slice from len..len" {
	251	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
243	252	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
244	253	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
245	254
...	...	@@ -252,6 +261,7 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
252	261	}
253	262
254	263	test "C pointer" {
	264	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
255	265	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
256	266	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
257	267
...	...	@@ -262,6 +272,7 @@ test "C pointer" {
262	272	}
263	273
264	274	test "C pointer slice access" {
	275	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
265	276	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
266	277	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
267	278
...	...	@@ -291,6 +302,7 @@ fn sliceSum(comptime q: []const u8) i32 {
291	302	}
292	303
293	304	test "slice type with custom alignment" {
	305	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
294	306	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
295	307	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
296	308
...	...	@@ -305,6 +317,7 @@ test "slice type with custom alignment" {
305	317	}
306	318
307	319	test "obtaining a null terminated slice" {
	320	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
308	321	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
309	322	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
310	323	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
...	...	@@ -350,6 +363,7 @@ test "empty array to slice" {
350	363	}
351	364
352	365	test "@ptrCast slice to pointer" {
	366	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
353	367	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
354	368	if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
355	369

test/behavior/struct.zig+28

...	...	@@ -9,6 +9,7 @@ const maxInt = std.math.maxInt;
9	9	top_level_field: i32,
10	10
11	11	test "top level fields" {
	12	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
12	13	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
13	14
14	15	var instance = @This(){
...	...	@@ -42,6 +43,7 @@ const StructWithFields = struct {
42	43	};
43	44
44	45	test "non-packed struct has fields padded out to the required alignment" {
	46	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
45	47	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
46	48
47	49	const foo = StructWithFields{ .a = 5, .b = 1, .c = 10, .d = 2 };
...	...	@@ -65,6 +67,7 @@ const SmallStruct = struct {
65	67	};
66	68
67	69	test "lower unnamed constants" {
	70	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
68	71	var foo = SmallStruct{ .a = 1, .b = 255 };
69	72	try expect(foo.first() == 1);
70	73	try expect(foo.second() == 255);
...	...	@@ -83,6 +86,7 @@ const StructFoo = struct {
83	86	};
84	87
85	88	test "structs" {
	89	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
86	90	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
87	91
88	92	var foo: StructFoo = undefined;
...	...	@@ -101,6 +105,7 @@ fn testMutation(foo: *StructFoo) void {
101	105	}
102	106
103	107	test "struct byval assign" {
	108	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
104	109	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
105	110
106	111	var foo1: StructFoo = undefined;
...	...	@@ -134,6 +139,7 @@ fn returnEmptyStructInstance() StructWithNoFields {
134	139	}
135	140
136	141	test "fn call of struct field" {
	142	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
137	143	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
138	144
139	145	const Foo = struct {
...	...	@@ -165,12 +171,14 @@ const MemberFnTestFoo = struct {
165	171	};
166	172
167	173	test "call member function directly" {
	174	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
168	175	const instance = MemberFnTestFoo{ .x = 1234 };
169	176	const result = MemberFnTestFoo.member(instance);
170	177	try expect(result == 1234);
171	178	}
172	179
173	180	test "store member function in variable" {
	181	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
174	182	const instance = MemberFnTestFoo{ .x = 1234 };
175	183	const memberFn = MemberFnTestFoo.member;
176	184	const result = memberFn(instance);
...	...	@@ -178,6 +186,7 @@ test "store member function in variable" {
178	186	}
179	187
180	188	test "member functions" {
	189	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
181	190	const r = MemberFnRand{ .seed = 1234 };
182	191	try expect(r.getSeed() == 1234);
183	192	}
...	...	@@ -189,6 +198,7 @@ const MemberFnRand = struct {
189	198	};
190	199
191	200	test "return struct byval from function" {
	201	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
192	202	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
193	203
194	204	const bar = makeBar2(1234, 5678);
...	...	@@ -206,6 +216,7 @@ fn makeBar2(x: i32, y: i32) Bar {
206	216	}
207	217
208	218	test "call method with mutable reference to struct with no fields" {
	219	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
209	220	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
210	221
211	222	const S = struct {
...	...	@@ -238,6 +249,7 @@ test "usingnamespace within struct scope" {
238	249	}
239	250
240	251	test "struct field init with catch" {
	252	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
241	253	if (builtin.zig_backend == .stage2_x86_64 or builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
242	254
243	255	const S = struct {
...	...	@@ -296,6 +308,7 @@ const Val = struct {
296	308	};
297	309
298	310	test "struct point to self" {
	311	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
299	312	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
300	313	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
301	314	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -314,6 +327,7 @@ test "struct point to self" {
314	327	}
315	328
316	329	test "void struct fields" {
	330	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
317	331	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
318	332	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
319	333	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -334,6 +348,7 @@ const VoidStructFieldsFoo = struct {
334	348	};
335	349
336	350	test "return empty struct from fn" {
	351	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
337	352	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
338	353	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
339	354	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -347,6 +362,7 @@ fn testReturnEmptyStructFromFn() EmptyStruct2 {
347	362	}
348	363
349	364	test "pass slice of empty struct to fn" {
	365	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
350	366	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
351	367	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
352	368	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -359,6 +375,7 @@ fn testPassSliceOfEmptyStructToFn(slice: []const EmptyStruct2) usize {
359	375	}
360	376
361	377	test "self-referencing struct via array member" {
	378	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
362	379	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
363	380	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
364	381	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -389,6 +406,7 @@ const EmptyStruct = struct {
389	406	};
390	407
391	408	test "align 1 field before self referential align 8 field as slice return type" {
	409	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
392	410	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
393	411	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
394	412	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -413,6 +431,7 @@ const APackedStruct = packed struct {
413	431	};
414	432
415	433	test "packed struct" {
	434	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
416	435	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
417	436	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
418	437	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -438,6 +457,7 @@ const Foo96Bits = packed struct {
438	457	};
439	458
440	459	test "packed struct 24bits" {
	460	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
441	461	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
442	462	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
443	463	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -484,6 +504,7 @@ test "packed struct 24bits" {
484	504	}
485	505
486	506	test "runtime struct initialization of bitfield" {
	507	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
487	508	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
488	509	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
489	510	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -523,6 +544,7 @@ const Bitfields = packed struct {
523	544	};
524	545
525	546	test "native bit field understands endianness" {
	547	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
526	548	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
527	549	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
528	550	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -546,6 +568,7 @@ test "native bit field understands endianness" {
546	568	}
547	569
548	570	test "implicit cast packed struct field to const ptr" {
	571	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
549	572	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
550	573	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
551	574	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -581,6 +604,7 @@ test "zero-bit field in packed struct" {
581	604	}
582	605
583	606	test "packed struct with non-ABI-aligned field" {
	607	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
584	608	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
585	609	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
586	610	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -610,6 +634,7 @@ const bit_field_1 = BitField1{
610	634	};
611	635
612	636	test "bit field access" {
	637	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
613	638	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
614	639	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
615	640	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -642,6 +667,7 @@ fn getC(data: *const BitField1) u2 {
642	667	}
643	668
644	669	test "default struct initialization fields" {
	670	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
645	671	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
646	672	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
647	673	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -907,6 +933,7 @@ test "packed struct field passed to generic function" {
907	933	}
908	934
909	935	test "anonymous struct literal syntax" {
	936	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
910	937	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
911	938	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
912	939	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -1100,6 +1127,7 @@ test "type coercion of pointer to anon struct literal to pointer to struct" {
1100	1127	}
1101	1128
1102	1129	test "packed struct with undefined initializers" {
	1130	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1103	1131	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
1104	1132	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1105	1133	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO

test/behavior/truncate.zig+9

...	...	@@ -3,6 +3,7 @@ const builtin = @import("builtin");
3	3	const expect = std.testing.expect;
4	4
5	5	test "truncate u0 to larger integer allowed and has comptime known result" {
	6	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6	7	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7	8
8	9	var x: u0 = 0;
...	...	@@ -11,6 +12,7 @@ test "truncate u0 to larger integer allowed and has comptime known result" {
11	12	}
12	13
13	14	test "truncate.u0.literal" {
	15	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
14	16	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
15	17
16	18	var z = @truncate(u0, 0);
...	...	@@ -18,6 +20,7 @@ test "truncate.u0.literal" {
18	20	}
19	21
20	22	test "truncate.u0.const" {
	23	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
21	24	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
22	25
23	26	const c0: usize = 0;
...	...	@@ -26,6 +29,7 @@ test "truncate.u0.const" {
26	29	}
27	30
28	31	test "truncate.u0.var" {
	32	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
29	33	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
30	34
31	35	var d: u8 = 2;
...	...	@@ -34,6 +38,7 @@ test "truncate.u0.var" {
34	38	}
35	39
36	40	test "truncate i0 to larger integer allowed and has comptime known result" {
	41	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
37	42	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
38	43
39	44	var x: i0 = 0;
...	...	@@ -42,6 +47,7 @@ test "truncate i0 to larger integer allowed and has comptime known result" {
42	47	}
43	48
44	49	test "truncate.i0.literal" {
	50	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
45	51	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
46	52
47	53	var z = @truncate(i0, 0);
...	...	@@ -49,6 +55,7 @@ test "truncate.i0.literal" {
49	55	}
50	56
51	57	test "truncate.i0.const" {
	58	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
52	59	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
53	60
54	61	const c0: isize = 0;
...	...	@@ -57,6 +64,7 @@ test "truncate.i0.const" {
57	64	}
58	65
59	66	test "truncate.i0.var" {
	67	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
60	68	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
61	69
62	70	var d: i8 = 2;
...	...	@@ -65,6 +73,7 @@ test "truncate.i0.var" {
65	73	}
66	74
67	75	test "truncate on comptime integer" {
	76	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
68	77	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
69	78
70	79	var x = @truncate(u16, 9999);

test/behavior/var_args.zig+3

...	...	@@ -25,6 +25,7 @@ fn readFirstVarArg(args: anytype) void {
25	25	}
26	26
27	27	test "send void arg to var args" {
	28	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
28	29	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
29	30	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
30	31	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -84,6 +85,7 @@ fn foo2(args: anytype) bool {
84	85	}
85	86
86	87	test "array of var args functions" {
	88	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
87	89	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
88	90	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
89	91	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
...	...	@@ -93,6 +95,7 @@ test "array of var args functions" {
93	95	}
94	96
95	97	test "pass zero length array to var args param" {
	98	if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
96	99	if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
97	100	if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
98	101	if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO