mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-20 00:08:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #11008 from joachimschmidt557/stage2-arm

Browse Source 
stage2 ARM: pass more behavior tests
This commit is contained in:
Jakub Konka 2022-02-28 09:59:44 +01:00 committed by GitHub
commit 90059a12e0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
30 changed files with 83 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
src/arch/arm/CodeGen.zig
View File

@ -433,7 +433,9 @@ fn gen(self: *Self) !void {
});
// exitlude jumps
if (self.exitlude_jump_relocs.items.len == 1) {
const only_one_exitlude_jump = self.exitlude_jump_relocs.items.len == 1 and
self.exitlude_jump_relocs.items[0] == self.mir_instructions.len - 1;
if (only_one_exitlude_jump) {
// There is only one relocation. Hence,
// this relocation must be at the end of
// the code. Therefore, we can just delete
@ -1066,7 +1068,17 @@ fn airMax(self: *Self, inst: Air.Inst.Index) !void {
fn airSlice(self: *Self, inst: Air.Inst.Index) !void {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const bin_op = self.air.extraData(Air.Bin, ty_pl.payload).data;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement slice for {}", .{self.target.cpu.arch});
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr = try self.resolveInst(bin_op.lhs);
const ptr_ty = self.air.typeOf(bin_op.lhs);
const len = try self.resolveInst(bin_op.rhs);
const len_ty = self.air.typeOf(bin_op.rhs);
const stack_offset = try self.allocMem(inst, 8, 8);
try self.genSetStack(ptr_ty, stack_offset + 4, ptr);
try self.genSetStack(len_ty, stack_offset, len);
break :result MCValue{ .stack_offset = stack_offset };
};
return self.finishAir(inst, result, .{ bin_op.lhs, bin_op.rhs, .none });
}
@ -1359,6 +1371,7 @@ fn airSliceElemVal(self: *Self, inst: Air.Inst.Index) !void {
const base_mcv: MCValue = switch (slice_mcv) {
.stack_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_offset = off + 4 }) },
.stack_argument_offset => |off| .{ .register = try self.copyToTmpRegister(slice_ptr_field_type, .{ .stack_argument_offset = off + 4 }) },
else => return self.fail("TODO slice_elem_val when slice is {}", .{slice_mcv}),
};
self.register_manager.freezeRegs(&.{base_mcv.register});
@ -3854,9 +3867,17 @@ fn airBitCast(self: *Self, inst: Air.Inst.Index) !void {
fn airArrayToSlice(self: *Self, inst: Air.Inst.Index) !void {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else return self.fail("TODO implement airArrayToSlice for {}", .{
self.target.cpu.arch,
});
const result: MCValue = if (self.liveness.isUnused(inst)) .dead else result: {
const ptr_ty = self.air.typeOf(ty_op.operand);
const ptr = try self.resolveInst(ty_op.operand);
const array_ty = ptr_ty.childType();
const array_len = @intCast(u32, array_ty.arrayLenIncludingSentinel());
const stack_offset = try self.allocMem(inst, 8, 8);
try self.genSetStack(ptr_ty, stack_offset + 4, ptr);
try self.genSetStack(Type.initTag(.usize), stack_offset, .{ .immediate = array_len });
break :result MCValue{ .stack_offset = stack_offset };
};
return self.finishAir(inst, result, .{ ty_op.operand, .none, .none });
}
@ -4077,6 +4098,9 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
}
switch (typed_value.ty.zigTypeTag()) {
.Array => {
return self.lowerUnnamedConst(typed_value);
},
.Pointer => switch (typed_value.ty.ptrSize()) {
.Slice => {
return self.lowerUnnamedConst(typed_value);

12
src/arch/arm/Mir.zig
View File

@ -118,8 +118,6 @@ pub const Inst = struct {
/// All instructions have a 8-byte payload, which is contained within
/// this union. `Tag` determines which union field is active, as well as
/// how to interpret the data within.
// TODO flatten down Data (remove use of tagged unions) to make it
// 8 bytes only
pub const Data = union {
/// No additional data
///
@ -231,11 +229,11 @@ pub const Inst = struct {
// Make sure we don't accidentally make instructions bigger than expected.
// Note that in Debug builds, Zig is allowed to insert a secret field for safety checks.
// comptime {
// if (builtin.mode != .Debug) {
// assert(@sizeOf(Data) == 8);
// }
// }
comptime {
if (builtin.mode != .Debug) {
assert(@sizeOf(Data) == 8);
}
}
};
pub fn deinit(mir: *Mir, gpa: std.mem.Allocator) void {

77
src/arch/arm/bits.zig
View File

@ -469,6 +469,23 @@ pub const Instruction = union(enum) {
}
};
pub const AddressingMode = enum {
/// [<Rn>, <offset>]
///
/// Address = Rn + offset
offset,
/// [<Rn>, <offset>]!
///
/// Address = Rn + offset
/// Rn = Rn + offset
pre_index,
/// [<Rn>], <offset>
///
/// Address = Rn
/// Rn = Rn + offset
post_index,
};
/// Represents the offset operand of a load or store
/// instruction. Data can be loaded from memory with either an
/// immediate offset or an offset that is stored in some register.
@ -730,10 +747,9 @@ pub const Instruction = union(enum) {
rd: Register,
rn: Register,
offset: Offset,
pre_index: bool,
mode: AddressingMode,
positive: bool,
byte_word: u1,
write_back: bool,
load_store: u1,
) Instruction {
return Instruction{
@ -743,10 +759,16 @@ pub const Instruction = union(enum) {
.rd = rd.id(),
.offset = offset.toU12(),
.load_store = load_store,
.write_back = @boolToInt(write_back),
.write_back = switch (mode) {
.offset => 0b0,
.pre_index, .post_index => 0b1,
},
.byte_word = byte_word,
.up_down = @boolToInt(positive),
.pre_post = @boolToInt(pre_index),
.pre_post = switch (mode) {
.offset, .pre_index => 0b1,
.post_index => 0b0,
},
.imm = @boolToInt(offset != .immediate),
},
};
@ -754,9 +776,8 @@ pub const Instruction = union(enum) {
fn extraLoadStore(
cond: Condition,
pre_index: bool,
mode: AddressingMode,
positive: bool,
write_back: bool,
o1: u1,
op2: u2,
rn: Register,
@ -780,10 +801,16 @@ pub const Instruction = union(enum) {
.rt = rt.id(),
.rn = rn.id(),
.o1 = o1,
.write_back = @boolToInt(write_back),
.write_back = switch (mode) {
.offset => 0b0,
.pre_index, .post_index => 0b1,
},
.imm = @boolToInt(offset == .immediate),
.up_down = @boolToInt(positive),
.pre_index = @boolToInt(pre_index),
.pre_index = switch (mode) {
.offset, .pre_index => 0b1,
.post_index => 0b0,
},
.cond = @enumToInt(cond),
},
};
@ -1091,51 +1118,49 @@ pub const Instruction = union(enum) {
// Single data transfer
pub const OffsetArgs = struct {
pre_index: bool = true,
mode: AddressingMode = .offset,
positive: bool = true,
offset: Offset,
write_back: bool = false,
};
pub fn ldr(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 0, args.write_back, 1);
return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 0, 1);
}
pub fn ldrb(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 1, args.write_back, 1);
return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 1, 1);
}
pub fn str(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 0, args.write_back, 0);
return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 0, 0);
}
pub fn strb(cond: Condition, rd: Register, rn: Register, args: OffsetArgs) Instruction {
return singleDataTransfer(cond, rd, rn, args.offset, args.pre_index, args.positive, 1, args.write_back, 0);
return singleDataTransfer(cond, rd, rn, args.offset, args.mode, args.positive, 1, 0);
}
// Extra load/store
pub const ExtraLoadStoreOffsetArgs = struct {
pre_index: bool = true,
mode: AddressingMode = .offset,
positive: bool = true,
offset: ExtraLoadStoreOffset,
write_back: bool = false,
};
pub fn strh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b0, 0b01, rn, rt, args.offset);
return extraLoadStore(cond, args.mode, args.positive, 0b0, 0b01, rn, rt, args.offset);
}
pub fn ldrh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b01, rn, rt, args.offset);
return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b01, rn, rt, args.offset);
}
pub fn ldrsh(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b11, rn, rt, args.offset);
return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b11, rn, rt, args.offset);
}
pub fn ldrsb(cond: Condition, rt: Register, rn: Register, args: ExtraLoadStoreOffsetArgs) Instruction {
return extraLoadStore(cond, args.pre_index, args.positive, args.write_back, 0b1, 0b10, rn, rt, args.offset);
return extraLoadStore(cond, args.mode, args.positive, 0b1, 0b10, rn, rt, args.offset);
}
// Block data transfer
@ -1234,10 +1259,9 @@ pub const Instruction = union(enum) {
} else if (args.len == 1) {
const reg = args[0];
return ldr(cond, reg, .sp, .{
.pre_index = false,
.mode = .post_index,
.positive = true,
.offset = Offset.imm(4),
.write_back = false,
});
} else {
var register_list: u16 = 0;
@ -1259,10 +1283,9 @@ pub const Instruction = union(enum) {
} else if (args.len == 1) {
const reg = args[0];
return str(cond, reg, .sp, .{
.pre_index = true,
.mode = .pre_index,
.positive = false,
.offset = Offset.imm(4),
.write_back = true,
});
} else {
var register_list: u16 = 0;
@ -1447,10 +1470,9 @@ test "aliases" {
.{ // pop { r6 }
.actual = Instruction.pop(.al, .{.r6}),
.expected = Instruction.ldr(.al, .r6, .sp, .{
.pre_index = false,
.mode = .post_index,
.positive = true,
.offset = Instruction.Offset.imm(4),
.write_back = false,
}),
},
.{ // pop { r1, r5 }
@ -1460,10 +1482,9 @@ test "aliases" {
.{ // push { r3 }
.actual = Instruction.push(.al, .{.r3}),
.expected = Instruction.str(.al, .r3, .sp, .{
.pre_index = true,
.mode = .pre_index,
.positive = false,
.offset = Instruction.Offset.imm(4),
.write_back = true,
}),
},
.{ // push { r0, r2 }

2
test/behavior/align.zig
View File

@ -6,8 +6,6 @@ const native_arch = builtin.target.cpu.arch;
var foo: u8 align(4) = 100;
test "global variable alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
comptime try expect(@TypeOf(&foo) == *align(4) u8);
{

5
test/behavior/array.zig
View File

@ -49,7 +49,6 @@ fn getArrayLen(a: []const u32) usize {
test "array init with mult" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const a = 'a';
var i: [8]u8 = [2]u8{ a, 'b' } ** 4;
@ -70,8 +69,6 @@ test "array literal with explicit type" {
}
test "array literal with inferred length" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const hex_mult = [_]u16{ 4096, 256, 16, 1 };
try expect(hex_mult.len == 4);
@ -100,7 +97,6 @@ test "array literal with specified size" {
test "array len field" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var arr = [4]u8{ 0, 0, 0, 0 };
var ptr = &arr;
@ -142,7 +138,6 @@ test "array with sentinels" {
test "void arrays" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var array: [4]void = undefined;
array[0] = void{};

7
test/behavior/basic.zig
View File

@ -120,14 +120,12 @@ test "return string from function" {
test "hex escape" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
try expect(mem.eql(u8, "\x68\x65\x6c\x6c\x6f", "hello"));
}
test "multiline string" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const s1 =
\\one
@ -140,7 +138,6 @@ test "multiline string" {
test "multiline string comments at start" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const s1 =
//\\one
@ -153,7 +150,6 @@ test "multiline string comments at start" {
test "multiline string comments at end" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const s1 =
\\one
@ -166,7 +162,6 @@ test "multiline string comments at end" {
test "multiline string comments in middle" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const s1 =
\\one
@ -179,7 +174,6 @@ test "multiline string comments in middle" {
test "multiline string comments at multiple places" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const s1 =
\\one
@ -198,7 +192,6 @@ test "string concatenation" {
test "array mult operator" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
try expect(mem.eql(u8, "ab" ** 5, "ababababab"));
}

6
test/behavior/bitcast.zig
View File

@ -76,7 +76,6 @@ fn conv_uN(comptime N: usize, x: std.meta.Int(.unsigned, N)) std.meta.Int(.signe
test "nested bitcast" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const S = struct {
fn moo(x: isize) !void {
@ -96,7 +95,6 @@ test "nested bitcast" {
test "@bitCast enum to its integer type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const SOCK = enum(c_int) {
A,
@ -116,7 +114,6 @@ test "@bitCast enum to its integer type" {
// issue #3010: compiler segfault
test "bitcast literal [4]u8 param to u32" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const ip = @bitCast(u32, [_]u8{ 255, 255, 255, 255 });
try expect(ip == maxInt(u32));
@ -124,7 +121,6 @@ test "bitcast literal [4]u8 param to u32" {
test "bitcast generates a temporary value" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var y = @as(u16, 0x55AA);
const x = @bitCast(u16, @bitCast([2]u8, y));
@ -247,7 +243,6 @@ test "bitcast packed struct literal to byte" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const Foo = packed struct {
value: u8,
@ -261,7 +256,6 @@ test "comptime bitcast used in expression has the correct type" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const Foo = packed struct {
value: u8,

1
test/behavior/bitreverse.zig
View File

@ -7,7 +7,6 @@ test "@bitReverse large exotic integer" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
// Currently failing on stage1 for big-endian targets
if (builtin.zig_backend == .stage1) return error.SkipZigTest;

1
test/behavior/bugs/3367.zig
View File

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

1
test/behavior/bugs/3586.zig
View File

@ -7,7 +7,6 @@ const Container = struct {
};
test "fixed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var ctr = Container{

1
test/behavior/bugs/4560.zig
View File

@ -2,7 +2,6 @@ const std = @import("std");
const builtin = @import("builtin");
test "fixed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var s: S = .{

1
test/behavior/bugs/704.zig
View File

@ -6,7 +6,6 @@ const xxx = struct {
}
};
test "bug 704" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var x: xxx = undefined;

6
test/behavior/cast.zig
View File

@ -273,7 +273,6 @@ test "*const ?[*]const T to [*c]const [*c]const T" {
test "array coersion to undefined at runtime" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
@setRuntimeSafety(true);
@ -337,7 +336,6 @@ test "peer type unsigned int to signed" {
test "expected [*c]const u8, found [*:0]const u8" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var a: [*:0]const u8 = "hello";
var b: [*c]const u8 = a;
@ -648,7 +646,6 @@ test "peer cast *[0]T to []const T" {
test "peer cast *[N]T to [*]T" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
var array = [4:99]i32{ 1, 2, 3, 4 };
@ -1067,7 +1064,6 @@ test "implicit cast *[0]T to E![]const u8" {
var global_array: [4]u8 = undefined;
test "cast from array reference to fn: comptime fn ptr" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
const f = @ptrCast(*const fn () callconv(.C) void, &global_array);
@ -1075,7 +1071,6 @@ test "cast from array reference to fn: comptime fn ptr" {
}
test "cast from array reference to fn: runtime fn ptr" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
var f = @ptrCast(*const fn () callconv(.C) void, &global_array);
@ -1100,7 +1095,6 @@ test "*const [N]null u8 to ?[]const u8" {
}
test "cast between [*c]T and ?[*:0]T on fn parameter" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
const S = struct {

2
test/behavior/defer.zig
View File

@ -5,7 +5,6 @@ const expectEqual = std.testing.expectEqual;
const expectError = std.testing.expectError;
test "break and continue inside loop inside defer expression" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
testBreakContInDefer(10);
@ -24,7 +23,6 @@ fn testBreakContInDefer(x: usize) void {
}
test "defer and labeled break" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var i = @as(usize, 0);

21
test/behavior/enum.zig
View File

@ -11,7 +11,6 @@ fn shouldEqual(n: Number, expected: u3) !void {
}
test "enum to int" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try shouldEqual(Number.Zero, 0);
@ -559,7 +558,6 @@ const ValueCount257 = enum {
};
test "enum sizes" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
comptime {
@ -571,7 +569,6 @@ test "enum sizes" {
}
test "enum literal equality" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const x = .hi;
@ -583,7 +580,6 @@ test "enum literal equality" {
}
test "enum literal cast to enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Color = enum { Auto, Off, On };
@ -594,7 +590,6 @@ test "enum literal cast to enum" {
}
test "peer type resolution with enum literal" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Items = enum { one, two };
@ -675,7 +670,6 @@ test "non-exhaustive enum" {
}
test "empty non-exhaustive enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
@ -741,7 +735,6 @@ const EnumWithTagValues = enum(u4) {
D = 1 << 3,
};
test "enum with tag values don't require parens" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(@enumToInt(EnumWithTagValues.C) == 0b0100);
@ -760,7 +753,6 @@ const MultipleChoice2 = enum(u32) {
};
test "cast integer literal to enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(@intToEnum(MultipleChoice2, 0) == MultipleChoice2.Unspecified1);
@ -795,7 +787,6 @@ const Small2 = enum(u2) { One, Two };
const Small = enum(u2) { One, Two, Three, Four };
test "set enum tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
{
@ -811,7 +802,6 @@ test "set enum tag type" {
}
test "casting enum to its tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testCastEnumTag(Small2.Two);
@ -823,7 +813,6 @@ fn testCastEnumTag(value: Small2) !void {
}
test "enum with 1 field but explicit tag type should still have the tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Enum = enum(u8) {
@ -833,7 +822,6 @@ test "enum with 1 field but explicit tag type should still have the tag type" {
}
test "signed integer as enum tag" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const SignedEnum = enum(i2) {
@ -848,7 +836,6 @@ test "signed integer as enum tag" {
}
test "enum with one member and custom tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const E = enum(u2) {
@ -862,7 +849,6 @@ test "enum with one member and custom tag type" {
}
test "enum with one member and u1 tag type @enumToInt" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Enum = enum(u1) {
@ -872,7 +858,6 @@ test "enum with one member and u1 tag type @enumToInt" {
}
test "enum with comptime_int tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Enum = enum(comptime_int) {
@ -884,7 +869,6 @@ test "enum with comptime_int tag type" {
}
test "enum with one member default to u0 tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const E0 = enum { X };
@ -903,7 +887,6 @@ fn doALoopThing(id: EnumWithOneMember) void {
}
test "comparison operator on enum with one member is comptime known" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
doALoopThing(EnumWithOneMember.Eof);
@ -911,7 +894,6 @@ test "comparison operator on enum with one member is comptime known" {
const State = enum { Start };
test "switch on enum with one member is comptime known" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var state = State.Start;
@ -922,7 +904,6 @@ test "switch on enum with one member is comptime known" {
}
test "method call on an enum" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {
@ -1117,7 +1098,6 @@ test "tag name with assigned enum values" {
}
test "@tagName on enum literals" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(mem.eql(u8, @tagName(.FooBar), "FooBar"));
@ -1184,7 +1164,6 @@ fn getC(data: *const BitFieldOfEnums) C {
}
test "enum literal in array literal" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Items = enum { one, two };

7
test/behavior/error.zig
View File

@ -6,7 +6,6 @@ const expectEqual = std.testing.expectEqual;
const mem = std.mem;
test "error values" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const a = @errorToInt(error.err1);
@ -15,7 +14,6 @@ test "error values" {
}
test "redefinition of error values allowed" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
shouldBeNotEqual(error.AnError, error.SecondError);
@ -39,7 +37,6 @@ fn errBinaryOperatorG(x: bool) anyerror!isize {
}
test "empty error union" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const x = error{} || error{};
@ -98,7 +95,6 @@ fn makeANonErr() anyerror!i32 {
}
test "syntax: optional operator in front of error union operator" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
comptime {
@ -157,7 +153,6 @@ test "implicit cast to optional to error union to return result loc" {
}
test "error: fn returning empty error set can be passed as fn returning any error" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
entry();
@ -178,7 +173,6 @@ fn bar2() (error{}!void) {}
test "error union type " {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
@ -197,7 +191,6 @@ fn testErrorUnionType() !void {
test "error set type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO

15
test/behavior/fn.zig
View File

@ -5,7 +5,6 @@ const expect = testing.expect;
const expectEqual = testing.expectEqual;
test "params" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(testParamsAdd(22, 11) == 33);
@ -15,7 +14,6 @@ fn testParamsAdd(a: i32, b: i32) i32 {
}
test "local variables" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
testLocVars(2);
@ -26,7 +24,6 @@ fn testLocVars(b: i32) void {
}
test "mutable local variables" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var zero: i32 = 0;
@ -40,7 +37,6 @@ test "mutable local variables" {
}
test "separate block scopes" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
{
@ -59,14 +55,12 @@ fn @"weird function name"() i32 {
return 1234;
}
test "weird function name" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(@"weird function name"() == 1234);
}
test "assign inline fn to const variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const a = inlineFn;
@ -86,7 +80,6 @@ fn outer(y: u32) *const fn (u32) u32 {
}
test "return inner function which references comptime variable of outer function" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage1) return error.SkipZigTest;
@ -156,7 +149,6 @@ test "inline function call that calls optional function pointer, return pointer
}
test "implicit cast function unreachable return" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
wantsFnWithVoid(fnWithUnreachable);
@ -209,7 +201,6 @@ test "function with complex callconv and return type expressions" {
}
test "pass by non-copying value" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
@ -238,7 +229,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
}
test "pass by non-copying value as method" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var pt = Point2{ .x = 1, .y = 2 };
@ -255,7 +245,6 @@ const Point2 = struct {
};
test "pass by non-copying value as method, which is generic" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var pt = Point3{ .x = 1, .y = 2 };
@ -273,7 +262,6 @@ const Point3 = struct {
};
test "pass by non-copying value as method, at comptime" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
comptime {
@ -325,7 +313,6 @@ fn voidFun(a: i32, b: void, c: i32, d: void) !void {
}
test "call function with empty string" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
acceptsString("");
@ -362,7 +349,6 @@ fn fn4() u32 {
}
test "number literal as an argument" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try numberLiteralArg(3);
@ -395,7 +381,6 @@ test "function call with anon list literal" {
}
test "ability to give comptime types and non comptime types to same parameter" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const S = struct {

3
test/behavior/for.zig
View File

@ -21,7 +21,6 @@ test "continue in for loop" {
}
test "break from outer for loop" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testBreakOuter();
@ -41,7 +40,6 @@ fn testBreakOuter() !void {
}
test "continue outer for loop" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testContinueOuter();
@ -61,7 +59,6 @@ fn testContinueOuter() !void {
}
test "ignore lval with underscore (for loop)" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
for ([_]void{}) |_, i| {

6
test/behavior/generics.zig
View File

@ -5,7 +5,6 @@ const expect = testing.expect;
const expectEqual = testing.expectEqual;
test "one param, explicit comptime" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var x: usize = 0;
@ -43,7 +42,6 @@ fn add(comptime a: i32, b: i32) i32 {
const the_max = max(u32, 1234, 5678);
test "compile time generic eval" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(the_max == 5678);
@ -144,7 +142,6 @@ pub fn SmallList(comptime T: type, comptime STATIC_SIZE: usize) type {
}
test "const decls in struct" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(GenericDataThing(3).count_plus_one == 4);
@ -156,7 +153,6 @@ fn GenericDataThing(comptime count: isize) type {
}
test "use generic param in generic param" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(aGenericFn(i32, 3, 4) == 7);
@ -201,7 +197,6 @@ test "generic fn keeps non-generic parameter types" {
}
test "array of generic fns" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
@ -223,7 +218,6 @@ fn foo2(arg: anytype) bool {
test "generic struct" {
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var a1 = GenNode(i32){
.value = 13,

4
test/behavior/if.zig
View File

@ -4,7 +4,6 @@ const expect = std.testing.expect;
const expectEqual = std.testing.expectEqual;
test "if statements" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
shouldBeEqual(1, 1);
@ -30,7 +29,6 @@ fn firstEqlThird(a: i32, b: i32, c: i32) void {
}
test "else if expression" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(elseIfExpressionF(1) == 1);
@ -67,7 +65,6 @@ test "unwrap mutable global var" {
}
test "labeled break inside comptime if inside runtime if" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var answer: i32 = 0;
@ -81,7 +78,6 @@ test "labeled break inside comptime if inside runtime if" {
}
test "const result loc, runtime if cond, else unreachable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const Num = enum { One, Two };

4
test/behavior/slice.zig
View File

@ -220,7 +220,6 @@ test "compile time slice of pointer to hard coded address" {
test "slice string literal has correct type" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime {
try expect(@TypeOf("aoeu"[0..]) == *const [4:0]u8);
@ -258,7 +257,6 @@ fn sliceFromLenToLen(a_slice: []u8, start: usize, end: usize) []u8 {
test "C pointer" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
var buf: [*c]const u8 = "kjdhfkjdhfdkjhfkfjhdfkjdhfkdjhfdkjhf";
var len: u32 = 10;
@ -357,7 +355,6 @@ test "empty array to slice" {
test "@ptrCast slice to pointer" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const S = struct {
fn doTheTest() !void {
@ -565,7 +562,6 @@ test "array concat of slices gives slice" {
}
test "slice bounds in comptime concatenation" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
const bs = comptime blk: {

7
test/behavior/struct.zig
View File

@ -215,7 +215,6 @@ fn makeBar2(x: i32, y: i32) Bar {
test "call method with mutable reference to struct with no fields" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const S = struct {
fn doC(s: *const @This()) bool {
@ -343,7 +342,6 @@ test "pass slice of empty struct to fn" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
try expect(testPassSliceOfEmptyStructToFn(&[_]EmptyStruct2{EmptyStruct2{}}) == 1);
}
@ -369,7 +367,6 @@ test "self-referencing struct via array member" {
test "empty struct method call" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const es = EmptyStruct{};
try expect(es.method() == 1234);
@ -567,7 +564,6 @@ test "implicit cast packed struct field to const ptr" {
test "zero-bit field in packed struct" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
const S = packed struct {
@ -645,7 +641,6 @@ test "default struct initialization fields" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct {
a: i32 = 1234,
@ -776,7 +771,6 @@ test "pointer to packed struct member in a stack variable" {
test "packed struct with u0 field access" {
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
@ -915,7 +909,6 @@ test "anonymous struct literal syntax" {
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
const S = struct {
const Point = struct {

1
test/behavior/this.zig
View File

@ -21,7 +21,6 @@ fn add(x: i32, y: i32) i32 {
}
test "this refer to module call private fn" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try expect(module.add(1, 2) == 3);

2
test/behavior/try.zig
View File

@ -25,7 +25,6 @@ fn returnsTen() anyerror!i32 {
}
test "try without vars" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const result1 = if (failIfTrue(true)) 1 else |_| @as(i32, 2);
@ -44,7 +43,6 @@ fn failIfTrue(ok: bool) anyerror!void {
}
test "try then not executed with assignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
if (failIfTrue(true)) {

1
test/behavior/type_info.zig
View File

@ -287,7 +287,6 @@ fn testUnion() !void {
}
test "type info: struct info" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try testStruct();

1
test/behavior/undefined.zig
View File

@ -77,7 +77,6 @@ test "assign undefined to struct with method" {
}
test "type name of undefined" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const x = undefined;

20
test/behavior/union.zig
View File

@ -43,8 +43,6 @@ fn setInt(foo: *Foo, x: i32) void {
}
test "comptime union field access" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime {
var foo = Foo{ .int = 0 };
try expect(foo.int == 0);
@ -75,14 +73,10 @@ const ExternPtrOrInt = extern union {
int: u64,
};
test "extern union size" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime try expect(@sizeOf(ExternPtrOrInt) == 8);
}
test "0-sized extern union definition" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const U = extern union {
a: void,
const f = 1;
@ -112,8 +106,6 @@ const err = @as(anyerror!Agg, Agg{
const array = [_]Value{ v1, v2, v1, v2 };
test "unions embedded in aggregate types" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
switch (array[1]) {
Value.Array => |arr| try expect(arr[4] == 3),
else => unreachable,
@ -125,8 +117,6 @@ test "unions embedded in aggregate types" {
}
test "access a member of tagged union with conflicting enum tag name" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const Bar = union(enum) {
A: A,
B: B,
@ -169,8 +159,6 @@ const TaggedUnionWithPayload = union(enum) {
};
test "union alignment" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime {
try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf([9]u8));
try expect(@alignOf(AlignTestTaggedUnion) >= @alignOf(u64));
@ -268,8 +256,6 @@ fn testCastUnionToTag() !void {
}
test "union field access gives the enum values" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
try expect(TheUnion.A == TheTag.A);
try expect(TheUnion.B == TheTag.B);
try expect(TheUnion.C == TheTag.C);
@ -343,8 +329,6 @@ const PackedPtrOrInt = packed union {
int: u64,
};
test "packed union size" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime try expect(@sizeOf(PackedPtrOrInt) == 8);
}
@ -352,8 +336,6 @@ const ZeroBits = union {
OnlyField: void,
};
test "union with only 1 field which is void should be zero bits" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
comptime try expect(@sizeOf(ZeroBits) == 0);
}
@ -411,8 +393,6 @@ test "union with only 1 field casted to its enum type" {
}
test "union with one member defaults to u0 tag type" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
const U0 = union(enum) {
X: u32,
};

4
test/behavior/usingnamespace.zig
View File

@ -11,7 +11,6 @@ const C = struct {
};
test "basic usingnamespace" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
try std.testing.expect(C.B == bool);
@ -24,7 +23,6 @@ fn Foo(comptime T: type) type {
}
test "usingnamespace inside a generic struct" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
const std2 = Foo(std);
@ -38,7 +36,6 @@ usingnamespace struct {
};
test "usingnamespace does not redeclare an imported variable" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
comptime try std.testing.expect(@This().foo == 42);
@ -57,7 +54,6 @@ fn privateFunction() bool {
}
test {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
_ = @import("usingnamespace/import_segregation.zig");

1
test/behavior/void.zig
View File

@ -43,7 +43,6 @@ test "void optional" {
}
test "void array as a local variable initializer" {
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
var x = [_]void{{}} ** 1004;

1
test/behavior/while.zig
View File

@ -249,7 +249,6 @@ fn returnTrue() bool {
test "return with implicit cast from while loop" {
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
returnWithImplicitCastFromWhileLoopTest() catch unreachable;