authorgravatar for kubkon@jakubkonka.comJakub Konka <kubkon@jakubkonka.com> 2022-02-28 09:59:44+01:00
committergravatar for noreply@github.comGitHub <noreply@github.com> 2022-02-28 09:59:44+01:00
log90059a12e0ffe433132450f9f43221a198a22106
tree9a5f89b41994cc10700df77d503be9f446b6f5fb
parent87dc60e8de58a392fe6e5e6b4dd5c41f487d367a
parent1bf8da19e1b58159b27033d415b7289cf455b870
signaturebadge-question-mark Signed by PGP key 4AEE18F83AFDEB23

Merge pull request #11008 from joachimschmidt557/stage2-arm

stage2 ARM: pass more behavior tests

30 files changed, 83 insertions(+), 171 deletions(-)

src/arch/arm/CodeGen.zig+29-5
......@@ -433,7 +433,9 @@ fn gen(self: *Self) !void {
433433 });
434434
435435 // exitlude jumps
436 if (self.exitlude_jump_relocs.items.len == 1) {
436 const only_one_exitlude_jump = self.exitlude_jump_relocs.items.len == 1 and
437 self.exitlude_jump_relocs.items[0] == self.mir_instructions.len - 1;
438 if (only_one_exitlude_jump) {
437439 // There is only one relocation. Hence,
438440 // this relocation must be at the end of
439441 // the code. Therefore, we can just delete
......@@ -1066,7 +1068,17 @@ fn airMax(self: *Self, inst: Air.Inst.Index) !void {
10661068fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
10671069 const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
10681070 const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
1069 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});
1071 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
1072 const ptr = try self.resolveInst(bin_op.lhs);
1073 const ptr_ty = self.air.typeOf(bin_op.lhs);
1074 const len = try self.resolveInst(bin_op.rhs);
1075 const len_ty = self.air.typeOf(bin_op.rhs);
1076
1077 const stack_offset = try self.allocMem(inst, 8, 8);
1078 try self.genSetStack(ptr_ty, stack_offset + 4, ptr);
1079 try self.genSetStack(len_ty, stack_offset, len);
1080 break :result MCValue{ .stack_offset = stack_offset };
1081 };
10701082 return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
10711083}
10721084
......@@ -1359,6 +1371,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
13591371
13601372 const base_mcv: MCValue = switch (slice_mcv) {
13611373 .stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off + 4 }) },
1374 .stack_argument_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_argument_offset = off + 4 }) },
13621375 else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
13631376 };
13641377 self.register_manager.freezeRegs(&.{base_mcv.register});
......@@ -3854,9 +3867,17 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
38543867
38553868fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
38563869 const ty_op = self.air.instructions.items(.data)[inst].ty_op;
3857 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airArrayToSlice for {}", .{
3858 self.target.cpu.arch,
3859 });
3870 const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
3871 const ptr_ty = self.air.typeOf(ty_op.operand);
3872 const ptr = try self.resolveInst(ty_op.operand);
3873 const array_ty = ptr_ty.childType();
3874 const array_len = @intCast(u32, array_ty.arrayLenIncludingSentinel());
3875
3876 const stack_offset = try self.allocMem(inst, 8, 8);
3877 try self.genSetStack(ptr_ty, stack_offset + 4, ptr);
3878 try self.genSetStack(Type.initTag(.usize), stack_offset, .{ .immediate = array_len });
3879 break :result MCValue{ .stack_offset = stack_offset };
3880 };
38603881 return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
38613882}
38623883
......@@ -4077,6 +4098,9 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
40774098 }
40784099
40794100 switch (typed_value.ty.zigTypeTag()) {
4101 .Array => {
4102 return self.lowerUnnamedConst(typed_value);
4103 },
40804104 .Pointer => switch (typed_value.ty.ptrSize()) {
40814105 .Slice => {
40824106 return self.lowerUnnamedConst(typed_value);
src/arch/arm/Mir.zig+5-7
......@@ -118,8 +118,6 @@ pub const Inst = struct {
118118 /// All instructions have a 8-byte payload, which is contained within
119119 /// this union. `Tag` determines which union field is active, as well as
120120 /// how to interpret the data within.
121 // TODO flatten down Data (remove use of tagged unions) to make it
122 // 8 bytes only
123121 pub const Data = union {
124122 /// No additional data
125123 ///
......@@ -231,11 +229,11 @@ pub const Inst = struct {
231229
232230 // Make sure we don't accidentally make instructions bigger than expected.
233231 // Note that in Debug builds, Zig is allowed to insert a secret field for safety checks.
234 // comptime {
235 // if (builtin.mode != .Debug) {
236 // assert(@sizeOf(Data) == 8);
237 // }
238 // }
232 comptime {
233 if (builtin.mode != .Debug) {
234 assert(@sizeOf(Data) == 8);
235 }
236 }
239237};
240238
241239pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {
src/arch/arm/bits.zig+49-28
......@@ -469,6 +469,23 @@ pub const Instruction = union(enum) {
469469 }
470470 };
471471
472 pub const AddressingMode = enum {
473 /// [<Rn>, <offset>]
474 ///
475 /// Address = Rn + offset
476 offset,
477 /// [<Rn>, <offset>]!
478 ///
479 /// Address = Rn + offset
480 /// Rn = Rn + offset
481 pre_index,
482 /// [<Rn>], <offset>
483 ///
484 /// Address = Rn
485 /// Rn = Rn + offset
486 post_index,
487 };
488
472489 /// Represents the offset operand of a load or store
473490 /// instruction. Data can be loaded from memory with either an
474491 /// immediate offset or an offset that is stored in some register.
......@@ -730,10 +747,9 @@ pub const Instruction = union(enum) {
730747 rd: Register,
731748 rn: Register,
732749 offset: Offset,
733 pre_index: bool,
750 mode: AddressingMode,
734751 positive: bool,
735752 byte_word: u1,
736 write_back: bool,
737753 load_store: u1,
738754 ) Instruction {
739755 return Instruction{
......@@ -743,10 +759,16 @@ pub const Instruction = union(enum) {
743759 .rd = rd.id(),
744760 .offset = offset.toU12(),
745761 .load_store = load_store,
746 .write_back = @boolToInt(write_back),
762 .write_back = switch (mode) {
763 .offset => 0b0,
764 .pre_index, .post_index => 0b1,
765 },
747766 .byte_word = byte_word,
748767 .up_down = @boolToInt(positive),
749 .pre_post = @boolToInt(pre_index),
768 .pre_post = switch (mode) {
769 .offset, .pre_index => 0b1,
770 .post_index => 0b0,
771 },
750772 .imm = @boolToInt(offset != .immediate),
751773 },
752774 };
......@@ -754,9 +776,8 @@ pub const Instruction = union(enum) {
754776
755777 fn extraLoadStore(
756778 cond: Condition,
757 pre_index: bool,
779 mode: AddressingMode,
758780 positive: bool,
759 write_back: bool,
760781 o1: u1,
761782 op2: u2,
762783 rn: Register,
......@@ -780,10 +801,16 @@ pub const Instruction = union(enum) {
780801 .rt = rt.id(),
781802 .rn = rn.id(),
782803 .o1 = o1,
783 .write_back = @boolToInt(write_back),
804 .write_back = switch (mode) {
805 .offset => 0b0,
806 .pre_index, .post_index => 0b1,
807 },
784808 .imm = @boolToInt(offset == .immediate),
785809 .up_down = @boolToInt(positive),
786 .pre_index = @boolToInt(pre_index),
810 .pre_index = switch (mode) {
811 .offset, .pre_index => 0b1,
812 .post_index => 0b0,
813 },
787814 .cond = @enumToInt(cond),
788815 },
789816 };
......@@ -1091,51 +1118,49 @@ pub const Instruction = union(enum) {
10911118 // Single data transfer
10921119
10931120 pub const OffsetArgs = struct {
1094 pre_index: bool = true,
1121 mode: AddressingMode = .offset,
10951122 positive: bool = true,
10961123 offset: Offset,
1097 write_back: bool = false,
10981124 };
10991125
11001126 pub fn ldr(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
1101 return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 0, args.write_back, 1);
1127 return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 0, 1);
11021128 }
11031129
11041130 pub fn ldrb(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
1105 return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 1, args.write_back, 1);
1131 return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 1, 1);
11061132 }
11071133
11081134 pub fn str(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
1109 return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 0, args.write_back, 0);
1135 return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 0, 0);
11101136 }
11111137
11121138 pub fn strb(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
1113 return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 1, args.write_back, 0);
1139 return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 1, 0);
11141140 }
11151141
11161142 // Extra load/store
11171143
11181144 pub const ExtraLoadStoreOffsetArgs = struct {
1119 pre_index: bool = true,
1145 mode: AddressingMode = .offset,
11201146 positive: bool = true,
11211147 offset: ExtraLoadStoreOffset,
1122 write_back: bool = false,
11231148 };
11241149
11251150 pub fn strh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
1126 return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b0, 0b01, rn, rt, args.offset);
1151 return extraLoadStore(cond, args.mode, args.positive, 0b0, 0b01, rn, rt, args.offset);
11271152 }
11281153
11291154 pub fn ldrh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
1130 return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b01, rn, rt, args.offset);
1155 return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b01, rn, rt, args.offset);
11311156 }
11321157
11331158 pub fn ldrsh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
1134 return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b11, rn, rt, args.offset);
1159 return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b11, rn, rt, args.offset);
11351160 }
11361161
11371162 pub fn ldrsb(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
1138 return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b10, rn, rt, args.offset);
1163 return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b10, rn, rt, args.offset);
11391164 }
11401165
11411166 // Block data transfer
......@@ -1234,10 +1259,9 @@ pub const Instruction = union(enum) {
12341259 } else if (args.len == 1) {
12351260 const reg = args[0];
12361261 return ldr(cond, reg, .sp, .{
1237 .pre_index = false,
1262 .mode = .post_index,
12381263 .positive = true,
12391264 .offset = Offset.imm(4),
1240 .write_back = false,
12411265 });
12421266 } else {
12431267 var register_list: u16 = 0;
......@@ -1259,10 +1283,9 @@ pub const Instruction = union(enum) {
12591283 } else if (args.len == 1) {
12601284 const reg = args[0];
12611285 return str(cond, reg, .sp, .{
1262 .pre_index = true,
1286 .mode = .pre_index,
12631287 .positive = false,
12641288 .offset = Offset.imm(4),
1265 .write_back = true,
12661289 });
12671290 } else {
12681291 var register_list: u16 = 0;
......@@ -1447,10 +1470,9 @@ test "aliases" {
14471470 .{ // pop { r6 }
14481471 .actual = Instruction.pop(.al, .{.r6}),
14491472 .expected = Instruction.ldr(.al, .r6, .sp, .{
1450 .pre_index = false,
1473 .mode = .post_index,
14511474 .positive = true,
14521475 .offset = Instruction.Offset.imm(4),
1453 .write_back = false,
14541476 }),
14551477 },
14561478 .{ // pop { r1, r5 }
......@@ -1460,10 +1482,9 @@ test "aliases" {
14601482 .{ // push { r3 }
14611483 .actual = Instruction.push(.al, .{.r3}),
14621484 .expected = Instruction.str(.al, .r3, .sp, .{
1463 .pre_index = true,
1485 .mode = .pre_index,
14641486 .positive = false,
14651487 .offset = Instruction.Offset.imm(4),
1466 .write_back = true,
14671488 }),
14681489 },
14691490 .{ // push { r0, r2 }
test/behavior/align.zig-2
......@@ -6,8 +6,6 @@ const native_arch = builtin.target.cpu.arch;
66var foo: u8 align(4) = 100;
77
88test "global variable alignment" {
9 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10
119 comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
1210 comptime try expect(@TypeOf(&foo) == *align(4) u8);
1311 {
test/behavior/array.zig-5
......@@ -49,7 +49,6 @@ fn getArrayLen(a: []const u32) usize {
4949
5050test "array init with mult" {
5151 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
52 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
5352
5453 const a = 'a';
5554 var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
......@@ -70,8 +69,6 @@ test "array literal with explicit type" {
7069}
7170
7271test "array literal with inferred length" {
73 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
74
7572 const hex_mult = [_]u16{ 4096, 256, 16, 1 };
7673
7774 try expect(hex_mult.len == 4);
......@@ -100,7 +97,6 @@ test "array literal with specified size" {
10097
10198test "array len field" {
10299 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
104100
105101 var arr = [4]u8{ 0, 0, 0, 0 };
106102 var ptr = &arr;
......@@ -142,7 +138,6 @@ test "array with sentinels" {
142138
143139test "void arrays" {
144140 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
145 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
146141
147142 var array: [4]void = undefined;
148143 array[0] = void{};
test/behavior/basic.zig-7
......@@ -120,14 +120,12 @@ test "return string from function" {
120120
121121test "hex escape" {
122122 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
123 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
124123
125124 try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
126125}
127126
128127test "multiline string" {
129128 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
130 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
131129
132130 const s1 =
133131 \\one
......@@ -140,7 +138,6 @@ test "multiline string" {
140138
141139test "multiline string comments at start" {
142140 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
143 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
144141
145142 const s1 =
146143 //\\one
......@@ -153,7 +150,6 @@ test "multiline string comments at start" {
153150
154151test "multiline string comments at end" {
155152 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
156 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
157153
158154 const s1 =
159155 \\one
......@@ -166,7 +162,6 @@ test "multiline string comments at end" {
166162
167163test "multiline string comments in middle" {
168164 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
169 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
170165
171166 const s1 =
172167 \\one
......@@ -179,7 +174,6 @@ test "multiline string comments in middle" {
179174
180175test "multiline string comments at multiple places" {
181176 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
182 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
183177
184178 const s1 =
185179 \\one
......@@ -198,7 +192,6 @@ test "string concatenation" {
198192
199193test "array mult operator" {
200194 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
201 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
202195
203196 try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
204197}
test/behavior/bitcast.zig-6
......@@ -76,7 +76,6 @@ fn conv_uN(comptime N: usize, x: std.meta.Int(.unsigned, N)) std.meta.Int(.signe
7676
7777test "nested bitcast" {
7878 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
79 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8079
8180 const S = struct {
8281 fn moo(x: isize) !void {
......@@ -96,7 +95,6 @@ test "nested bitcast" {
9695
9796test "@bitCast enum to its integer type" {
9897 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10098
10199 const SOCK = enum(c_int) {
102100 A,
......@@ -116,7 +114,6 @@ test "@bitCast enum to its integer type" {
116114// issue #3010: compiler segfault
117115test "bitcast literal [4]u8 param to u32" {
118116 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
119 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
120117
121118 const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });
122119 try expect(ip == maxInt(u32));
......@@ -124,7 +121,6 @@ test "bitcast literal [4]u8 param to u32" {
124121
125122test "bitcast generates a temporary value" {
126123 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
127 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
128124
129125 var y = @as(u16, 0x55AA);
130126 const x = @bitCast(u16, @bitCast([2]u8, y));
......@@ -247,7 +243,6 @@ test "bitcast packed struct literal to byte" {
247243 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
248244 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
249245 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
250 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
251246
252247 const Foo = packed struct {
253248 value: u8,
......@@ -261,7 +256,6 @@ test "comptime bitcast used in expression has the correct type" {
261256 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
262257 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
263258 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
264 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
265259
266260 const Foo = packed struct {
267261 value: u8,
test/behavior/bitreverse.zig-1
......@@ -7,7 +7,6 @@ test "@bitReverse large exotic integer" {
77 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
88 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
99 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1110 // Currently failing on stage1 for big-endian targets
1211 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
1312
test/behavior/bugs/3367.zig-1
......@@ -12,7 +12,6 @@ const Mixin = struct {
1212test "container member access usingnamespace decls" {
1313 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1414 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
15 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1615 var foo = Foo{};
1716 foo.two();
1817}
test/behavior/bugs/3586.zig-1
......@@ -7,7 +7,6 @@ const Container = struct {
77};
88
99test "fixed" {
10 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1110 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1211
1312 var ctr = Container{
test/behavior/bugs/4560.zig-1
......@@ -2,7 +2,6 @@ const std = @import("std");
22const builtin = @import("builtin");
33
44test "fixed" {
5 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
65 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
76
87 var s: S = .{
test/behavior/bugs/704.zig-1
......@@ -6,7 +6,6 @@ const xxx = struct {
66 }
77};
88test "bug 704" {
9 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1110
1211 var x: xxx = undefined;
test/behavior/cast.zig-6
......@@ -273,7 +273,6 @@ test "*const ?[*]const T to [*c]const [*c]const T" {
273273
274274test "array coersion to undefined at runtime" {
275275 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
277276
278277 @setRuntimeSafety(true);
279278
......@@ -337,7 +336,6 @@ test "peer type unsigned int to signed" {
337336
338337test "expected [*c]const u8, found [*:0]const u8" {
339338 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
340 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
341339
342340 var a: [*:0]const u8 = "hello";
343341 var b: [*c]const u8 = a;
......@@ -648,7 +646,6 @@ test "peer cast *[0]T to []const T" {
648646test "peer cast *[N]T to [*]T" {
649647 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
650648 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
651 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
652649 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
653650
654651 var array = [4:99]i32{ 1, 2, 3, 4 };
......@@ -1067,7 +1064,6 @@ test "implicit cast *[0]T to E![]const u8" {
10671064
10681065var global_array: [4]u8 = undefined;
10691066test "cast from array reference to fn: comptime fn ptr" {
1070 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10711067 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10721068
10731069 const f = @ptrCast(*const fn () callconv(.C) void, &global_array);
......@@ -1075,7 +1071,6 @@ test "cast from array reference to fn: comptime fn ptr" {
10751071}
10761072test "cast from array reference to fn: runtime fn ptr" {
10771073 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
1078 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
10791074 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
10801075
10811076 var f = @ptrCast(*const fn () callconv(.C) void, &global_array);
......@@ -1100,7 +1095,6 @@ test "*const [N]null u8 to ?[]const u8" {
11001095}
11011096
11021097test "cast between [*c]T and ?[*:0]T on fn parameter" {
1103 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
11041098 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
11051099
11061100 const S = struct {
test/behavior/defer.zig-2
......@@ -5,7 +5,6 @@ const expectEqual = std.testing.expectEqual;
55const expectError = std.testing.expectError;
66
77test "break and continue inside loop inside defer expression" {
8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109
1110 testBreakContInDefer(10);
......@@ -24,7 +23,6 @@ fn testBreakContInDefer(x: usize) void {
2423}
2524
2625test "defer and labeled break" {
27 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2826 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2927
3028 var i = @as(usize, 0);
test/behavior/enum.zig-21
......@@ -11,7 +11,6 @@ fn shouldEqual(n: Number, expected: u3) !void {
1111}
1212
1313test "enum to int" {
14 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1615
1716 try shouldEqual(Number.Zero, 0);
......@@ -559,7 +558,6 @@ const ValueCount257 = enum {
559558};
560559
561560test "enum sizes" {
562 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
563561 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
564562
565563 comptime {
......@@ -571,7 +569,6 @@ test "enum sizes" {
571569}
572570
573571test "enum literal equality" {
574 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
575572 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
576573
577574 const x = .hi;
......@@ -583,7 +580,6 @@ test "enum literal equality" {
583580}
584581
585582test "enum literal cast to enum" {
586 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
587583 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
588584
589585 const Color = enum { Auto, Off, On };
......@@ -594,7 +590,6 @@ test "enum literal cast to enum" {
594590}
595591
596592test "peer type resolution with enum literal" {
597 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
598593 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
599594
600595 const Items = enum { one, two };
......@@ -675,7 +670,6 @@ test "non-exhaustive enum" {
675670}
676671
677672test "empty non-exhaustive enum" {
678 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
679673 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
680674
681675 const S = struct {
......@@ -741,7 +735,6 @@ const EnumWithTagValues = enum(u4) {
741735 D = 1 << 3,
742736};
743737test "enum with tag values don't require parens" {
744 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
745738 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
746739
747740 try expect(@enumToInt(EnumWithTagValues.C) == 0b0100);
......@@ -760,7 +753,6 @@ const MultipleChoice2 = enum(u32) {
760753};
761754
762755test "cast integer literal to enum" {
763 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
764756 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
765757
766758 try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
......@@ -795,7 +787,6 @@ const Small2 = enum(u2) { One, Two };
795787const Small = enum(u2) { One, Two, Three, Four };
796788
797789test "set enum tag type" {
798 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
799790 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
800791
801792 {
......@@ -811,7 +802,6 @@ test "set enum tag type" {
811802}
812803
813804test "casting enum to its tag type" {
814 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
815805 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
816806
817807 try testCastEnumTag(Small2.Two);
......@@ -823,7 +813,6 @@ fn testCastEnumTag(value: Small2) !void {
823813}
824814
825815test "enum with 1 field but explicit tag type should still have the tag type" {
826 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
827816 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
828817
829818 const Enum = enum(u8) {
......@@ -833,7 +822,6 @@ test "enum with 1 field but explicit tag type should still have the tag type" {
833822}
834823
835824test "signed integer as enum tag" {
836 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
837825 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
838826
839827 const SignedEnum = enum(i2) {
......@@ -848,7 +836,6 @@ test "signed integer as enum tag" {
848836}
849837
850838test "enum with one member and custom tag type" {
851 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
852839 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
853840
854841 const E = enum(u2) {
......@@ -862,7 +849,6 @@ test "enum with one member and custom tag type" {
862849}
863850
864851test "enum with one member and u1 tag type @enumToInt" {
865 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
866852 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
867853
868854 const Enum = enum(u1) {
......@@ -872,7 +858,6 @@ test "enum with one member and u1 tag type @enumToInt" {
872858}
873859
874860test "enum with comptime_int tag type" {
875 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
876861 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
877862
878863 const Enum = enum(comptime_int) {
......@@ -884,7 +869,6 @@ test "enum with comptime_int tag type" {
884869}
885870
886871test "enum with one member default to u0 tag type" {
887 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
888872 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
889873
890874 const E0 = enum { X };
......@@ -903,7 +887,6 @@ fn doALoopThing(id: EnumWithOneMember) void {
903887}
904888
905889test "comparison operator on enum with one member is comptime known" {
906 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
907890 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
908891
909892 doALoopThing(EnumWithOneMember.Eof);
......@@ -911,7 +894,6 @@ test "comparison operator on enum with one member is comptime known" {
911894
912895const State = enum { Start };
913896test "switch on enum with one member is comptime known" {
914 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
915897 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
916898
917899 var state = State.Start;
......@@ -922,7 +904,6 @@ test "switch on enum with one member is comptime known" {
922904}
923905
924906test "method call on an enum" {
925 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
926907 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
927908
928909 const S = struct {
......@@ -1117,7 +1098,6 @@ test "tag name with assigned enum values" {
11171098}
11181099
11191100test "@tagName on enum literals" {
1120 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11211101 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11221102
11231103 try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
......@@ -1184,7 +1164,6 @@ fn getC(data: *const BitFieldOfEnums) C {
11841164}
11851165
11861166test "enum literal in array literal" {
1187 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
11881167 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
11891168
11901169 const Items = enum { one, two };
test/behavior/error.zig-7
......@@ -6,7 +6,6 @@ const expectEqual = std.testing.expectEqual;
66const mem = std.mem;
77
88test "error values" {
9 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
109 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1110
1211 const a = @errorToInt(error.err1);
......@@ -15,7 +14,6 @@ test "error values" {
1514}
1615
1716test "redefinition of error values allowed" {
18 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1917 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2018
2119 shouldBeNotEqual(error.AnError, error.SecondError);
......@@ -39,7 +37,6 @@ fn errBinaryOperatorG(x: bool) anyerror!isize {
3937}
4038
4139test "empty error union" {
42 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4340 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4441
4542 const x = error{} || error{};
......@@ -98,7 +95,6 @@ fn makeANonErr() anyerror!i32 {
9895}
9996
10097test "syntax: optional operator in front of error union operator" {
101 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
10298 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
10399
104100 comptime {
......@@ -157,7 +153,6 @@ test "implicit cast to optional to error union to return result loc" {
157153}
158154
159155test "error: fn returning empty error set can be passed as fn returning any error" {
160 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
161156 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
162157
163158 entry();
......@@ -178,7 +173,6 @@ fn bar2() (error{}!void) {}
178173test "error union type " {
179174 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
180175 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
181 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
182176 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
183177 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
184178
......@@ -197,7 +191,6 @@ fn testErrorUnionType() !void {
197191test "error set type" {
198192 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
199193 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
200 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
201194 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
202195 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
203196
test/behavior/fn.zig-15
......@@ -5,7 +5,6 @@ const expect = testing.expect;
55const expectEqual = testing.expectEqual;
66
77test "params" {
8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109
1110 try expect(testParamsAdd(22, 11) == 33);
......@@ -15,7 +14,6 @@ fn testParamsAdd(a: i32, b: i32) i32 {
1514}
1615
1716test "local variables" {
18 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1917 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2018
2119 testLocVars(2);
......@@ -26,7 +24,6 @@ fn testLocVars(b: i32) void {
2624}
2725
2826test "mutable local variables" {
29 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3027 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3128
3229 var zero: i32 = 0;
......@@ -40,7 +37,6 @@ test "mutable local variables" {
4037}
4138
4239test "separate block scopes" {
43 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4440 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4541
4642 {
......@@ -59,14 +55,12 @@ fn @"weird function name"() i32 {
5955 return 1234;
6056}
6157test "weird function name" {
62 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6358 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6459
6560 try expect(@"weird function name"() == 1234);
6661}
6762
6863test "assign inline fn to const variable" {
69 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7064 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7165
7266 const a = inlineFn;
......@@ -86,7 +80,6 @@ fn outer(y: u32) *const fn (u32) u32 {
8680}
8781
8882test "return inner function which references comptime variable of outer function" {
89 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
9083 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
9184
9285 if (builtin.zig_backend == .stage1) return error.SkipZigTest;
......@@ -156,7 +149,6 @@ test "inline function call that calls optional function pointer, return pointer
156149}
157150
158151test "implicit cast function unreachable return" {
159 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
160152 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161153
162154 wantsFnWithVoid(fnWithUnreachable);
......@@ -209,7 +201,6 @@ test "function with complex callconv and return type expressions" {
209201}
210202
211203test "pass by non-copying value" {
212 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
213204 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
214205
215206 try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
......@@ -238,7 +229,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
238229}
239230
240231test "pass by non-copying value as method" {
241 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
242232 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
243233
244234 var pt = Point2{ .x = 1, .y = 2 };
......@@ -255,7 +245,6 @@ const Point2 = struct {
255245};
256246
257247test "pass by non-copying value as method, which is generic" {
258 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
259248 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
260249
261250 var pt = Point3{ .x = 1, .y = 2 };
......@@ -273,7 +262,6 @@ const Point3 = struct {
273262};
274263
275264test "pass by non-copying value as method, at comptime" {
276 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
277265 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
278266
279267 comptime {
......@@ -325,7 +313,6 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
325313}
326314
327315test "call function with empty string" {
328 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
329316 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
330317
331318 acceptsString("");
......@@ -362,7 +349,6 @@ fn fn4() u32 {
362349}
363350
364351test "number literal as an argument" {
365 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
366352 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
367353
368354 try numberLiteralArg(3);
......@@ -395,7 +381,6 @@ test "function call with anon list literal" {
395381}
396382
397383test "ability to give comptime types and non comptime types to same parameter" {
398 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
399384 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
400385
401386 const S = struct {
test/behavior/for.zig-3
......@@ -21,7 +21,6 @@ test "continue in for loop" {
2121}
2222
2323test "break from outer for loop" {
24 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2524 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2625
2726 try testBreakOuter();
......@@ -41,7 +40,6 @@ fn testBreakOuter() !void {
4140}
4241
4342test "continue outer for loop" {
44 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4543 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4644
4745 try testContinueOuter();
......@@ -61,7 +59,6 @@ fn testContinueOuter() !void {
6159}
6260
6361test "ignore lval with underscore (for loop)" {
64 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6562 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6663
6764 for ([_]void{}) |_, i| {
test/behavior/generics.zig-6
......@@ -5,7 +5,6 @@ const expect = testing.expect;
55const expectEqual = testing.expectEqual;
66
77test "one param, explicit comptime" {
8 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
98 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
109
1110 var x: usize = 0;
......@@ -43,7 +42,6 @@ fn add(comptime a: i32, b: i32) i32 {
4342
4443const the_max = max(u32, 1234, 5678);
4544test "compile time generic eval" {
46 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4745 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4846
4947 try expect(the_max == 5678);
......@@ -144,7 +142,6 @@ pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
144142}
145143
146144test "const decls in struct" {
147 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
148145 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
149146
150147 try expect(GenericDataThing(3).count_plus_one == 4);
......@@ -156,7 +153,6 @@ fn GenericDataThing(comptime count: isize) type {
156153}
157154
158155test "use generic param in generic param" {
159 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
160156 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
161157
162158 try expect(aGenericFn(i32, 3, 4) == 7);
......@@ -201,7 +197,6 @@ test "generic fn keeps non-generic parameter types" {
201197}
202198
203199test "array of generic fns" {
204 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
205200 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
206201 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
207202
......@@ -223,7 +218,6 @@ fn foo2(arg: anytype) bool {
223218
224219test "generic struct" {
225220 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
226 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
227221 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
228222 var a1 = GenNode(i32){
229223 .value = 13,
test/behavior/if.zig-4
......@@ -4,7 +4,6 @@ const expect = std.testing.expect;
44const expectEqual = std.testing.expectEqual;
55
66test "if statements" {
7 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
87 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
98
109 shouldBeEqual(1, 1);
......@@ -30,7 +29,6 @@ fn firstEqlThird(a: i32, b: i32, c: i32) void {
3029}
3130
3231test "else if expression" {
33 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
3432 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3533
3634 try expect(elseIfExpressionF(1) == 1);
......@@ -67,7 +65,6 @@ test "unwrap mutable global var" {
6765}
6866
6967test "labeled break inside comptime if inside runtime if" {
70 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
7168 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
7269
7370 var answer: i32 = 0;
......@@ -81,7 +78,6 @@ test "labeled break inside comptime if inside runtime if" {
8178}
8279
8380test "const result loc, runtime if cond, else unreachable" {
84 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8581 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8682
8783 const Num = enum { One, Two };
test/behavior/slice.zig-4
......@@ -220,7 +220,6 @@ test "compile time slice of pointer to hard coded address" {
220220
221221test "slice string literal has correct type" {
222222 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
223 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
224223
225224 comptime {
226225 try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
......@@ -258,7 +257,6 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
258257
259258test "C pointer" {
260259 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
261 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
262260
263261 var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
264262 var len: u32 = 10;
......@@ -357,7 +355,6 @@ test "empty array to slice" {
357355
358356test "@ptrCast slice to pointer" {
359357 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
360 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
361358
362359 const S = struct {
363360 fn doTheTest() !void {
......@@ -565,7 +562,6 @@ test "array concat of slices gives slice" {
565562}
566563
567564test "slice bounds in comptime concatenation" {
568 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
569565 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
570566
571567 const bs = comptime blk: {
test/behavior/struct.zig-7
......@@ -215,7 +215,6 @@ fn makeBar2(x: i32, y: i32) Bar {
215215
216216test "call method with mutable reference to struct with no fields" {
217217 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
218 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
219218
220219 const S = struct {
221220 fn doC(s: *const @This()) bool {
......@@ -343,7 +342,6 @@ test "pass slice of empty struct to fn" {
343342 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
344343 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
345344 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
346 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
347345
348346 try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
349347}
......@@ -369,7 +367,6 @@ test "self-referencing struct via array member" {
369367test "empty struct method call" {
370368 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
371369 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
372 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
373370
374371 const es = EmptyStruct{};
375372 try expect(es.method() == 1234);
......@@ -567,7 +564,6 @@ test "implicit cast packed struct field to const ptr" {
567564test "zero-bit field in packed struct" {
568565 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
569566 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
570 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
571567 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
572568
573569 const S = packed struct {
......@@ -645,7 +641,6 @@ test "default struct initialization fields" {
645641 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
646642 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
647643 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
648 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
649644
650645 const S = struct {
651646 a: i32 = 1234,
......@@ -776,7 +771,6 @@ test "pointer to packed struct member in a stack variable" {
776771test "packed struct with u0 field access" {
777772 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
778773 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
779 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
780774 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
781775 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
782776
......@@ -915,7 +909,6 @@ test "anonymous struct literal syntax" {
915909 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
916910 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
917911 if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
918 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
919912
920913 const S = struct {
921914 const Point = struct {
test/behavior/this.zig-1
......@@ -21,7 +21,6 @@ fn add(x: i32, y: i32) i32 {
2121}
2222
2323test "this refer to module call private fn" {
24 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2524 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2625
2726 try expect(module.add(1, 2) == 3);
test/behavior/try.zig-2
......@@ -25,7 +25,6 @@ fn returnsTen() anyerror!i32 {
2525}
2626
2727test "try without vars" {
28 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2928 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
3029
3130 const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2);
......@@ -44,7 +43,6 @@ fn failIfTrue(ok: bool) anyerror!void {
4443}
4544
4645test "try then not executed with assignment" {
47 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4846 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4947
5048 if (failIfTrue(true)) {
test/behavior/type_info.zig-1
......@@ -287,7 +287,6 @@ fn testUnion() !void {
287287}
288288
289289test "type info: struct info" {
290 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
291290 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
292291
293292 try testStruct();
test/behavior/undefined.zig-1
......@@ -77,7 +77,6 @@ test "assign undefined to struct with method" {
7777}
7878
7979test "type name of undefined" {
80 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
8180 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
8281
8382 const x = undefined;
test/behavior/union.zig-20
......@@ -43,8 +43,6 @@ fn setInt(foo: *Foo, x: i32) void {
4343}
4444
4545test "comptime union field access" {
46 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
47
4846 comptime {
4947 var foo = Foo{ .int = 0 };
5048 try expect(foo.int == 0);
......@@ -75,14 +73,10 @@ const ExternPtrOrInt = extern union {
7573 int: u64,
7674};
7775test "extern union size" {
78 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
79
8076 comptime try expect(@sizeOf(ExternPtrOrInt) == 8);
8177}
8278
8379test "0-sized extern union definition" {
84 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
85
8680 const U = extern union {
8781 a: void,
8882 const f = 1;
......@@ -112,8 +106,6 @@ const err = @as(anyerror!Agg, Agg{
112106const array = [_]Value{ v1, v2, v1, v2 };
113107
114108test "unions embedded in aggregate types" {
115 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
116
117109 switch (array[1]) {
118110 Value.Array => |arr| try expect(arr[4] == 3),
119111 else => unreachable,
......@@ -125,8 +117,6 @@ test "unions embedded in aggregate types" {
125117}
126118
127119test "access a member of tagged union with conflicting enum tag name" {
128 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
129
130120 const Bar = union(enum) {
131121 A: A,
132122 B: B,
......@@ -169,8 +159,6 @@ const TaggedUnionWithPayload = union(enum) {
169159};
170160
171161test "union alignment" {
172 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
173
174162 comptime {
175163 try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf([9]u8));
176164 try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf(u64));
......@@ -268,8 +256,6 @@ fn testCastUnionToTag() !void {
268256}
269257
270258test "union field access gives the enum values" {
271 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
272
273259 try expect(TheUnion.A == TheTag.A);
274260 try expect(TheUnion.B == TheTag.B);
275261 try expect(TheUnion.C == TheTag.C);
......@@ -343,8 +329,6 @@ const PackedPtrOrInt = packed union {
343329 int: u64,
344330};
345331test "packed union size" {
346 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
347
348332 comptime try expect(@sizeOf(PackedPtrOrInt) == 8);
349333}
350334
......@@ -352,8 +336,6 @@ const ZeroBits = union {
352336 OnlyField: void,
353337};
354338test "union with only 1 field which is void should be zero bits" {
355 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
356
357339 comptime try expect(@sizeOf(ZeroBits) == 0);
358340}
359341
......@@ -411,8 +393,6 @@ test "union with only 1 field casted to its enum type" {
411393}
412394
413395test "union with one member defaults to u0 tag type" {
414 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
415
416396 const U0 = union(enum) {
417397 X: u32,
418398 };
test/behavior/usingnamespace.zig-4
......@@ -11,7 +11,6 @@ const C = struct {
1111};
1212
1313test "basic usingnamespace" {
14 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
1514 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
1615
1716 try std.testing.expect(C.B == bool);
......@@ -24,7 +23,6 @@ fn Foo(comptime T: type) type {
2423}
2524
2625test "usingnamespace inside a generic struct" {
27 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
2826 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
2927
3028 const std2 = Foo(std);
......@@ -38,7 +36,6 @@ usingnamespace struct {
3836};
3937
4038test "usingnamespace does not redeclare an imported variable" {
41 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4239 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4340
4441 comptime try std.testing.expect(@This().foo == 42);
......@@ -57,7 +54,6 @@ fn privateFunction() bool {
5754}
5855
5956test {
60 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
6157 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
6258
6359 _ = @import("usingnamespace/import_segregation.zig");
test/behavior/void.zig-1
......@@ -43,7 +43,6 @@ test "void optional" {
4343}
4444
4545test "void array as a local variable initializer" {
46 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
4746 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
4847
4948 var x = [_]void{{}} ** 1004;
test/behavior/while.zig-1
......@@ -249,7 +249,6 @@ fn returnTrue() bool {
249249
250250test "return with implicit cast from while loop" {
251251 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
252 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
253252 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
254253
255254 returnWithImplicitCastFromWhileLoopTest() catch unreachable;